First commit

author: AlmightyMiau <almightymeow612@gmail.com> 2024-10-26 13:06:14 -0700
committer: AlmightyMiau <almightymeow612@gmail.com> 2024-10-26 13:06:14 -0700
commit: 1ca00b3b73a9699e41f81e154cea32934c16de03 (patch)
tree: d8ff8fe937b06cf40458aac232953b19665bcc6e
47 files changed, 3479 insertions, 0 deletions
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..df68a56
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+# Bitburner
diff --git a/bitburnerFiles1026/0port.txt b/bitburnerFiles1026/0port.txt
new file mode 100644
index 0000000..c40a43a
--- /dev/null
+++ b/bitburnerFiles1026/0port.txt
@@ -0,0 +1,7 @@
+n00dles
+foodnstuff
+sigma-cosmetics
+joesguns
+hong-fang-tea
+harakiri-sushi
+nectar-net
+\ No newline at end of file
diff --git a/bitburnerFiles1026/1port.txt b/bitburnerFiles1026/1port.txt
new file mode 100644
index 0000000..513acd8
--- /dev/null
+++ b/bitburnerFiles1026/1port.txt
@@ -0,0 +1,5 @@
+zer0
+max-hardware
+iron-gym
+neo-net
+CSEC
+\ No newline at end of file
diff --git a/bitburnerFiles1026/2port.txt b/bitburnerFiles1026/2port.txt
new file mode 100644
index 0000000..98135b3
--- /dev/null
+++ b/bitburnerFiles1026/2port.txt
@@ -0,0 +1,7 @@
+phantasy
+omega-net
+avmnite-02h
+crush-fitness
+the-hub
+silver-helix
+johnson-ortho
+\ No newline at end of file
diff --git a/bitburnerFiles1026/3port.txt b/bitburnerFiles1026/3port.txt
new file mode 100644
index 0000000..1e68e88
--- /dev/null
+++ b/bitburnerFiles1026/3port.txt
@@ -0,0 +1,8 @@
+computek
+netlink
+I.I.I.I
+rothman-uni
+summit-uni
+catalyst
+millenium-fitness
+rho-construction
diff --git a/bitburnerFiles1026/4port.txt b/bitburnerFiles1026/4port.txt
new file mode 100644
index 0000000..563cca7
--- /dev/null
+++ b/bitburnerFiles1026/4port.txt
@@ -0,0 +1,10 @@
+aevum-police
+global-pharm
+syscore
+lexo-corp
+unitalife
+snap-fitness
+alpha-ent
+univ-energy
+nova-med
+zb-def
+\ No newline at end of file
diff --git a/bitburnerFiles1026/5port.txt b/bitburnerFiles1026/5port.txt
new file mode 100644
index 0000000..4139a28
--- /dev/null
+++ b/bitburnerFiles1026/5port.txt
@@ -0,0 +1,11 @@
+zb-institute
+galactic-cyber
+aerocorp
+omnia
+deltaone
+taiyang-digital
+icarus
+zeus-med
+infocomm
+solaris
+defcomm
+\ No newline at end of file
diff --git a/bitburnerFiles1026/augbaseprice.txt b/bitburnerFiles1026/augbaseprice.txt
new file mode 100644
index 0000000..cbe955a
--- /dev/null
+++ b/bitburnerFiles1026/augbaseprice.txt
@@ -0,0 +1 @@
+419229000000
+\ No newline at end of file
diff --git a/bitburnerFiles1026/augments.js b/bitburnerFiles1026/augments.js
new file mode 100644
index 0000000..c6a7f60
--- /dev/null
+++ b/bitburnerFiles1026/augments.js
@@ -0,0 +1,130 @@
+/** @param {NS} ns */
+export async function main(ns) {
+
+	ns.tail();
+	ns.moveTail(950, 300);
+	ns.resizeTail(250, 100);
+
+	// ns.disableLog("disableLog");
+	// ns.disableLog("clearLog");
+	ns.disableLog("sleep");
+	// ns.disableLog("singularity.getAugmentationRepReq");
+	// ns.disableLog("singularity.getAugmentationPrice");
+	ns.disableLog("singularity.donateToFaction");
+	ns.disableLog("getServerMoneyAvailable");
+	ns.clearLog();
+
+	// Buffer time after game startup so it will read properly
+	await ns.sleep(6000);
+
+	// INITIALIZE
+	let owned = ns.singularity.getOwnedAugmentations(true);  // Get the currently owned augments
+	const baseprice = ns.read("augbaseprice.txt");           // Get the base price from the start of the installation
+	let n;                                                   // No clue
+
+	while (true) {
+		let factions = ns.getPlayer().factions;
+		for (let i = 0; i < factions.length; i++) {
+			if (factions[i] == "Shadows of Anarchy") { continue; }
+
+			let augs = ns.singularity.getAugmentationsFromFaction(factions[i]);
+			
+			for (let j = 0; j < augs.length; j++) {
+				if (augs[j] == "NeuroFlux Governor" || owned.includes(augs[j])) { continue; }
+				if (augs[j] == "The Red Pill") {
+					if (ns.singularity.getFactionFavor(factions[i]) < 150) {
+						if ((ns.singularity.getFactionFavorGain(factions[i]) + ns.singularity.getFactionFavor(factions[i])) > 150) {
+							ns.singularity.installAugmentations("start.js");
+						}
+					} else if (ns.singularity.getFactionRep(factions[i]) >= ns.singularity.getAugmentationRepReq(augs[j])) {
+						ns.singularity.purchaseAugmentation(factions[i], augs[j]);
+						await ns.sleep(500);
+						ns.singularity.installAugmentations("start.js");
+					} else if (ns.singularity.getFactionRep(factions[i]) < ns.singularity.getAugmentationRepReq(augs[j]) && ns.getPlayer().money > 10000000) {
+						ns.singularity.donateToFaction(factions[i], (ns.getPlayer().money - 10000000));
+					}
+				}
+
+				if (ns.singularity.getFactionRep(factions[i]) > ns.singularity.getAugmentationRepReq(augs[j])) {
+					if (ns.getPlayer().money > ns.singularity.getAugmentationPrice(augs[j])) {
+						if (ns.singularity.purchaseAugmentation(factions[i], augs[j])) {
+							ns.print("Buying ", augs[j]);
+							owned.push(augs[j]);
+						}
+					}
+				} else if (!n) {
+					ns.singularity.workForFaction(factions[i], "hacking", false);
+					n = factions[i];
+				}
+			}
+			if (augs.length == 0 && n == factions[i]) {
+				n = "";
+			}
+		}
+		if ((ns.singularity.getAugmentationPrice("NeuroFlux Governor") / baseprice) > 16000) {
+			ns.singularity.installAugmentations("start.js");
+		}
+		if (owned.includes("The Red Pill") && !ns.singularity.getOwnedAugmentations(false).includes("The Red Pill")) {
+			ns.singularity.installAugmentations("start.js");
+		}
+		if (ns.singularity.getOwnedAugmentations(false).includes("The Red Pill")) {
+			ns.singularity.workForFaction("Sector-12", "hacking", false);
+			while (true) {
+				ns.clearLog();
+				// if ((Date.now() - ns.getResetInfo().lastAugReset) > 3600000) { 
+				// 	while (ns.singularity.getAugmentationPrice("NeuroFlux Governor") < ns.getPlayer().money) {
+				// 		if (ns.singularity.getAugmentationRepReq("NeuroFlux Governor") < ns.singularity.getFactionRep("Sector-12")) { 
+				// 			ns.singularity.purchaseAugmentation("Sector-12", "NeuroFlux Governor"); 
+				// 		} else { 
+				// 			ns.singularity.donateToFaction("Sector-12", ns.getPlayer().money - ns.singularity.getAugmentationPrice("NeuroFlux Governor") - 10e9)
+				// 		}
+				// 		await ns.sleep(100);
+				// 	}
+				// 	try { ns.singularity.installAugmentations("start.js"); }
+				// 	catch {
+				// 		while (ns.singularity.installAugmentations("start.js")) {
+				// 			try { ns.singularity.purchaseAugmentation("Sector-12", "NeuroFlux Governor"); }
+				// 			catch {}
+				// 			await ns.sleep(100);
+				// 		}
+				// 	} 
+				// } else { 
+				// 	ns.print("Time since last reset: ", Math.round((Date.now() - ns.getResetInfo().lastAugReset) / 60), " minutes"); 
+				// }
+				if ((ns.singularity.getAugmentationPrice("NeuroFlux Governor") / baseprice) > 16000) {
+					ns.singularity.installAugmentations("start.js");
+				} else { 
+					ns.print("Current price multiplier: ", Math.round(ns.singularity.getAugmentationPrice("NeuroFlux Governor") / baseprice));
+					ns.print("Current price: ", formatLargeNumber(Math.round(5*10e10 + (ns.singularity.getAugmentationPrice("NeuroFlux Governor")))));
+				}
+				if (ns.getPlayer().money > (5*10e10 + ns.singularity.getAugmentationPrice("NeuroFlux Governor"))) {
+					if (ns.singularity.getAugmentationRepReq("NeuroFlux Governor") <= ns.singularity.getFactionRep("Sector-12")) {
+						ns.singularity.purchaseAugmentation("Sector-12", "NeuroFlux Governor");
+					}
+				} else { ns.print("Need more money: ", (100 * Math.floor(ns.getPlayer().money) / Math.ceil(5*10e10 + ns.singularity.getAugmentationPrice("NeuroFlux Governor"))).toFixed(4), "%")}
+
+				if (ns.singularity.getFactionRep("Sector-12") < ns.singularity.getAugmentationRepReq("NeuroFlux Governor")) {
+					ns.print("Current reputation: ", formatLargeNumber(ns.singularity.getFactionRep("Sector-12")));
+					ns.print("Reputation needed: ", formatLargeNumber(ns.singularity.getAugmentationRepReq("NeuroFlux Governor") - ns.singularity.getFactionRep("Sector-12")));
+					if (ns.getPlayer().money > (5*10e10 + ns.singularity.getAugmentationPrice("NeuroFlux Governor"))) {
+						ns.singularity.donateToFaction("Sector-12", ns.getPlayer().money - (5*10e10 + ns.singularity.getAugmentationPrice("NeuroFlux Governor")));
+					}
+				}
+				await ns.sleep(6000);
+			}
+		}
+		await ns.sleep(6000);
+	}
+}
+
+function formatLargeNumber(number) {
+    const suffixes = ['', ' thousand', ' million', ' billion', ' trillion', ' quadrillion', ' quintillion', ' sextillion', ' septillion', ' octillion', ' nonillion', ' decillion'];
+    let suffixIndex = 0;
+
+    while (number >= 1000 && suffixIndex < suffixes.length - 1) {
+        number /= 1000;
+        suffixIndex++;
+    }
+
+    return number.toFixed(2).replace(/\.00$/, '') + suffixes[suffixIndex];
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/autoinfiltrate.js b/bitburnerFiles1026/autoinfiltrate.js
new file mode 100644
index 0000000..eb7717f
--- /dev/null
+++ b/bitburnerFiles1026/autoinfiltrate.js
@@ -0,0 +1,803 @@
+// This script is awesome and will autocomplete the infiltrate tasks in bitburner.
+// It does not always run properly, it could be a browser issue and works 95% with game running on edge browser.
+// This was copied from https://pastebin.com/7DuFYDpJ and modified to work with shadows of anarchy augments.
+// Type "wget https://raw.githubusercontent.com/5p0ng3b0b/bitburner-scripts/main/autoinfiltrate.js autoinfiltrate.js" from you home terminal to download.
+// Type 'run autoinfiltrate.js' from home terminal. options are --start --stop --quiet although the --start option is not required.
+// Try always running it via an alias eg 'alias autoinfil="run autoinfiltrate.js --stop --quiet; run autoinfiltrate.js --quiet""
+// Once the script is running, It will activate when you visit any company and click the infiltrate button.
+// You can use infiltrate to quickly get alot of money early in the game or quickly earn rep for any faction.
+// ecorp in Aevum is the highest earner followed by megacorp in sector-12 and then KuaiGong International in Chongqing.
+
+
+const state = {
+	// Name of the company that's infiltrated.
+	company: "",
+
+	// Whether infiltration started. False means, we're
+	// waiting to arrive on the infiltration screen.
+	started: false,
+
+	// Details/state of the current mini game.
+	// Is reset after every game.
+	game: {},
+};
+
+// Speed of game actions, in milliseconds. Default 22
+const speed = 25;
+
+// Small hack to save RAM.
+// This will work smoothly, because the script does not use
+// any "ns" functions, it's a pure browser automation tool.
+const wnd = eval("window");
+const doc = wnd["document"];
+
+// List of all games and an automated solver.
+const infiltrationGames = [
+	{
+		name: "type it",
+		init: function (screen) {
+			const lines = getLines(getEl(screen, "p"));
+			state.game.data = lines[0].split("");
+		},
+		play: function (screen) {
+			if (!state.game.data || !state.game.data.length) {
+				delete state.game.data;
+				return;
+			}
+
+			pressKey(state.game.data.shift());
+		},
+	},	
+	{
+		name: "type it backward",
+		init: function (screen) {
+			const lines = getLines(getEl(screen, "p"));
+			state.game.data = lines[0].split("");
+		},
+		play: function (screen) {
+			if (!state.game.data || !state.game.data.length) {
+				delete state.game.data;
+				return;
+			}
+
+			pressKey(state.game.data.shift());
+		},
+	},
+	{
+		// name: "enter the code",
+		init: function (screen) { },
+		play: function (screen) {
+			const h4 = getEl(screen, "h4");
+			const spanElements = h4[1].querySelectorAll("span");
+			const code = Array.from(spanElements)
+				.filter(span => span.textContent !== "?")
+				.map(span => span.textContent)
+				.pop();
+
+			switch (code) {
+				case "↑":
+					pressKey("w");
+					break;
+				case "↓":
+					pressKey("s");
+					break;
+				case "←":
+					pressKey("a");
+					break;
+				case "→":
+					pressKey("d");
+					break;
+			}
+		},
+	},
+	{
+		name: "close the brackets",
+		init: function (screen) {
+			const data = getLines(getEl(screen, "p"));
+			const brackets = data.join("").split("");
+			state.game.data = [];
+
+			for (let i = brackets.length - 1; i >= 0; i--) {
+				const char = brackets[i];
+
+				if ("<" == char) {
+					state.game.data.push(">");
+				} else if ("(" == char) {
+					state.game.data.push(")");
+				} else if ("{" == char) {
+					state.game.data.push("}");
+				} else if ("[" == char) {
+					state.game.data.push("]");
+				}
+			}
+		},
+		play: function (screen) {
+			if (!state.game.data || !state.game.data.length) {
+				delete state.game.data;
+				return;
+			}
+
+			pressKey(state.game.data.shift());
+		},
+	},
+	{
+		name: "Attack after the guard drops his guard and is distracted. Do not alert him!",
+		init: function (screen) {
+			state.game.data = "wait";
+		},
+		play: function (screen) {
+			const data = getLines(getEl(screen, "h4"));
+
+			if ("Distracted!" === state.game.data) {
+				pressKey(" ");
+				state.game.data = "done";
+			}
+
+			// Attack in next frame - instant attack sometimes
+			// ends in failure.
+			if ('wait' === state.game.data && -1 !== data.indexOf("Alerted!")) {
+				state.game.data = "attack";
+			}
+		},
+	},
+	{
+		name: "say something nice about the guard",
+		init: function (screen) { },
+		play: function (screen) {
+			const correct = [
+				"affectionate",
+				"agreeable",
+				"bright",
+				"charming",
+				"creative",
+				"determined",
+				"energetic",
+				"friendly",
+				"funny",
+				"generous",
+				"polite",
+				"likable",
+				"diplomatic",
+				"helpful",
+				"giving",
+				"kind",
+				"hardworking",
+				"patient",
+				"dynamic",
+				"loyal",
+				"based",
+				"straightforward"
+			];
+			const word = getLines(getEl(screen, "h5"))[1];
+
+			if (-1 !== correct.indexOf(word)) {
+				pressKey(" ");
+			} else {
+				pressKey("w");
+			}
+		},
+	},
+	{
+		name: "remember all the mines",
+		init: function (screen) {
+			const rows = getEl(screen, "p");
+			let gridSize = null;
+			switch (rows.length) {
+				case 9:
+					gridSize = [3, 3];
+					break;
+				case 12:
+					gridSize = [3, 4];
+					break;
+				case 16:
+					gridSize = [4, 4];
+					break;
+				case 20:
+					gridSize = [4, 5];
+					break;
+				case 25:
+					gridSize = [5, 5];
+					break;
+				case 30:
+					gridSize = [5, 6];
+					break;
+				case 36:
+					gridSize = [6, 6];
+					break;
+			}
+			if (gridSize == null) {
+				return;
+			}
+			//12 20 30 42
+			state.game.data = [];
+			let index = 0;
+			//for each row
+			for (let y = 0; y < gridSize[1]; y++) {
+				//initialize array data
+				state.game.data[y] = [];
+				for (let x = 0; x < gridSize[0]; x++) {
+					//for each column in the row add to state data if it has a child
+					if (rows[index].children.length > 0) {
+						state.game.data[y].push(true);
+					} else state.game.data[y].push(false);
+					index += 1;
+				}
+			}
+		},
+		play: function (screen) { },
+	},
+	{
+		name: "mark all the mines",
+		init: function (screen) {
+			state.game.x = 0;
+			state.game.y = 0;
+			state.game.cols = state.game.data[0].length;
+			state.game.dir = 1;
+		},
+		play: function (screen) {
+			let { data, x, y, cols, dir } = state.game;
+
+			if (data[y][x]) {
+				pressKey(" ");
+				data[y][x] = false;
+			}
+
+			x += dir;
+
+			if (x < 0 || x >= cols) {
+				x = Math.max(0, Math.min(cols - 1, x));
+				y++;
+				dir *= -1;
+				pressKey("s");
+			} else {
+				pressKey(dir > 0 ? "d" : "a");
+			}
+
+			state.game.data = data;
+			state.game.x = x;
+			state.game.y = y;
+			state.game.dir = dir;
+		},
+	},
+	{
+		name: "match the symbols",
+		init: function (screen) {
+			const data = getLines(getEl(screen, "h5 span"));
+			const rows = getLines(getEl(screen, "p"));
+			const keypad = [];
+			const targets = [];
+			let gridSize = null;
+			switch (rows.length) {
+				case 9:
+					gridSize = [3, 3];
+					break;
+				case 12:
+					gridSize = [3, 4];
+					break;
+				case 16:
+					gridSize = [4, 4];
+					break;
+				case 20:
+					gridSize = [4, 5];
+					break;
+				case 25:
+					gridSize = [5, 5];
+					break;
+				case 30:
+					gridSize = [5, 6];
+					break;
+				case 36:
+					gridSize = [6, 6];
+					break;
+			}
+			if (gridSize == null) {
+				return;
+			}
+			//build the keypad grid.
+			let index = 0;
+			for (let i = 0; i < gridSize[1]; i++) {
+				keypad[i] = [];
+				for (let y = 0; y < gridSize[0]; y++) {
+
+					keypad[i].push(rows[index]);
+					index += 1;
+				}
+			}
+			//foreach data get coords of keypad entry
+			for (let i = 0; i < data.length; i++) {
+				const symbol = data[i].trim();
+				//for each keypad entry
+				for (let j = 0; j < keypad.length; j++) {
+					const k = keypad[j].indexOf(symbol);
+
+					if (-1 !== k) {
+						targets.push([j, k]);
+						break;
+					}
+				}
+			}
+			state.game.data = targets;
+			state.game.x = 0;
+			state.game.y = 0;
+		},
+		play: function (screen) {
+			const target = state.game.data[0];
+			let { x, y } = state.game;
+
+			if (!target) {
+				return;
+			}
+
+			const to_y = target[0];
+			const to_x = target[1];
+
+			if (to_y < y) {
+				y--;
+				pressKey("w");
+			} else if (to_y > y) {
+				y++;
+				pressKey("s");
+			} else if (to_x < x) {
+				x--;
+				pressKey("a");
+			} else if (to_x > x) {
+				x++;
+				pressKey("d");
+			} else {
+				pressKey(" ");
+				state.game.data.shift();
+			}
+
+			state.game.x = x;
+			state.game.y = y;
+		},
+	},
+	{
+		name: "cut the wires with the following properties",
+		init: function (screen) {
+			let numberHack = ["1", "2", "3", "4", "5", "6", "7", "8", "9"];
+			const colors = {
+				red: "red",
+				white: "white",
+				blue: "blue",
+				"rgb(255, 193, 7)": "yellow",
+			};
+			const wireColor = {
+				red: [],
+				white: [],
+				blue: [],
+				yellow: [],
+			};
+			//gather the instructions
+			var instructions = []
+			for (let child of screen.children) instructions.push(child);
+			var wiresData = instructions.pop();
+			instructions.shift();
+			instructions = getLines(instructions);
+			//get the wire information
+			const samples = getEl(wiresData, "p");
+			const wires = [];
+			//get the amount of wires
+			let wireCount = 0;
+			for (let i = wireCount; i < samples.length; i++) {
+				if (numberHack.includes(samples[i].innerText)) wireCount += 1;
+				else break;
+			}
+			let index = 0;
+			//get just the first 3 rows of wires.
+			for (let i = 0; i < 3; i++) {
+				//for each row
+				for (let j = 0; j < wireCount; j++) {
+					const node = samples[index];
+					const color = colors[node.style.color];
+					if (!color) {
+						index += 1;
+						continue;
+					}
+					wireColor[color].push(j + 1);
+					index += 1;
+				}
+			}
+
+			for (let i = 0; i < instructions.length; i++) {
+				const line = instructions[i].trim().toLowerCase();
+
+				if (!line || line.length < 10) {
+					continue;
+				}
+				if (-1 !== line.indexOf("cut wires number")) {
+					const parts = line.split(/(number\s*|\.)/);
+					wires.push(parseInt(parts[2]));
+				}
+				if (-1 !== line.indexOf("cut all wires colored")) {
+					const parts = line.split(/(colored\s*|\.)/);
+					const color = parts[2];
+
+					if (!wireColor[color]) {
+						// should never happen.
+						continue;
+					}
+
+					wireColor[color].forEach((num) => wires.push(num));
+				}
+			}
+
+			// new Set() removes duplicate elements.
+			state.game.data = [...new Set(wires)];
+		},
+		play: function (screen) {
+			const wire = state.game.data;
+			//state.game.data.shift();
+			if (!wire) {
+				return;
+			}
+			for (let i = 0; i < wire.length; i++) {
+				pressKey(wire[i].toString());
+			}
+		},
+	},
+];
+
+/** @param {NS} ns **/
+export async function main(ns) {
+	const args = ns.flags([
+		["start", false],
+		["stop", false],
+		["status", false],
+		["quiet", false],
+	]);
+
+	function print(msg) {
+		if (!args.quiet) {
+			ns.tprint(`\n${msg}\n`);
+		}
+	}
+
+	if (args.status) {
+		if (wnd.tmrAutoInf) {
+			print("Automated infiltration is active");
+		} else {
+			print("Automated infiltration is inactive");
+		}
+		return;
+	}
+
+	if (wnd.tmrAutoInf) {
+		print("Stopping automated infiltration...");
+		clearInterval(wnd.tmrAutoInf);
+		delete wnd.tmrAutoInf;
+	}
+
+	if (args.stop) {
+		return;
+	}
+
+	print(
+		"Automated infiltration is enabled...\nVWhen you visit the infiltration screen of any company, all tasks are completed automatically."
+	);
+
+	endInfiltration();
+
+	// Monitor the current screen and start infiltration once a
+	// valid screen is detected.
+	wnd.tmrAutoInf = setInterval(infLoop, speed);
+
+	// Modify the addEventListener logic.
+	wrapEventListeners();
+}
+
+/**
+ * The infiltration loop, which is called at a rapid interval
+ */
+function infLoop() {
+	if (!state.started) {
+		waitForStart();
+	} else {
+		playGame();
+	}
+}
+
+/**
+ * Returns a list of DOM elements from the main game
+ * container.
+ */
+function getEl(parent, selector) {
+	let prefix = ":scope";
+
+	if ("string" === typeof parent) {
+		selector = parent;
+		parent = doc;
+
+		prefix = ".MuiBox-root>.MuiBox-root>.MuiBox-root";
+
+		if (!doc.querySelectorAll(prefix).length) {
+			prefix = ".MuiBox-root>.MuiBox-root>.MuiGrid-root";
+		}
+		if (!doc.querySelectorAll(prefix).length) {
+			prefix = ".MuiContainer-root>.MuiPaper-root";
+		}
+		if (!doc.querySelectorAll(prefix).length) {
+			return [];
+		}
+	}
+
+	selector = selector.split(",");
+	selector = selector.map((item) => `${prefix} ${item}`);
+	selector = selector.join(",");
+
+	return parent.querySelectorAll(selector);
+}
+
+/**
+ * Returns the first element with matching text content.
+ */
+function filterByText(elements, text) {
+	text = text.toLowerCase();
+
+	for (let i = 0; i < elements.length; i++) {
+		const content = elements[i].textContent.toLowerCase();
+
+		if (-1 !== content.indexOf(text)) {
+			return elements[i];
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Returns an array with the text-contents of the given elements.
+ *
+ * @param {NodeList} elements
+ * @returns {string[]}
+ */
+function getLines(elements) {
+	const lines = [];
+	elements.forEach((el) => lines.push(el.textContent));
+
+	return lines;
+}
+
+/**
+ * Reset the state after infiltration is done.
+ */
+function endInfiltration() {
+	unwrapEventListeners();
+	state.company = "";
+	state.started = false;
+}
+
+/**
+ * Simulate a keyboard event (keydown + keyup).
+ *
+ * @param {string|int} keyOrCode A single letter (string) or key-code to send.
+ */
+function pressKey(keyOrCode) {
+	let keyCode = 0;
+	let key = "";
+
+	if ("string" === typeof keyOrCode && keyOrCode.length > 0) {
+		key = keyOrCode.toLowerCase().substr(0, 1);
+		keyCode = key.charCodeAt(0);
+	} else if ("number" === typeof keyOrCode) {
+		keyCode = keyOrCode;
+		key = String.fromCharCode(keyCode);
+	}
+
+	if (!keyCode || key.length !== 1) {
+		return;
+	}
+
+	function sendEvent(event) {
+		const keyboardEvent = new KeyboardEvent(event, {
+			key,
+			keyCode,
+		});
+
+		doc.dispatchEvent(keyboardEvent);
+	}
+
+	sendEvent("keydown");
+}
+
+/**
+ * Infiltration monitor to start automatic infiltration.
+ *
+ * This function runs asynchronously, after the "main" function ended,
+ * so we cannot use any "ns" function here!
+ */
+function waitForStart() {
+	if (state.started) {
+		return;
+	}
+
+	const h4 = getEl("h4");
+
+	if (!h4.length) {
+		return;
+	}
+	const title = h4[0].textContent;
+	if (0 !== title.indexOf("Infiltrating")) {
+		return;
+	}
+
+	const btnStart = filterByText(getEl("button"), "Start");
+	if (!btnStart) {
+		return;
+	}
+
+	state.company = title.substr(13);
+	state.started = true;
+	wrapEventListeners();
+
+	console.log("Start automatic infiltration of", state.company);
+	btnStart.click();
+}
+
+/**
+ * Identify the current infiltration game.
+ */
+function playGame() {
+	const screens = doc.querySelectorAll(".MuiContainer-root");
+
+	if (!screens.length) {
+		endInfiltration();
+		return;
+	}
+	if (screens[0].children.length < 3) {
+		return;
+	}
+
+	const screen = screens[0].children[2];
+	const h4 = getEl(screen, "h4");
+
+	if (!h4.length) {
+		endInfiltration();
+		return;
+	}
+
+	const title = h4[0].textContent.trim().toLowerCase().split(/[!.(]/)[0];
+
+	if ("infiltration successful" === title) {
+		endInfiltration();
+		return;
+	}
+
+	if ("get ready" === title) {
+		return;
+	}
+
+	const game = infiltrationGames.find((game) => game.name === title);
+
+	if (game) {
+		if (state.game.current !== title) {
+			state.game.current = title;
+			game.init(screen);
+		}
+
+		game.play(screen);
+	} else {
+		console.error("Unknown game:", title);
+	}
+}
+
+/**
+ * Wrap all event listeners with a custom function that injects
+ * the "isTrusted" flag.
+ *
+ * Is this cheating? Or is it real hacking? Don't care, as long
+ * as it's working :)
+ */
+function wrapEventListeners() {
+	if (!doc._addEventListener) {
+		doc._addEventListener = doc.addEventListener;
+
+		doc.addEventListener = function (type, callback, options) {
+			if ("undefined" === typeof options) {
+				options = false;
+			}
+			let handler = false;
+
+			// For this script, we only want to modify "keydown" events.
+			if ("keydown" === type) {
+				handler = function (...args) {
+					if (!args[0].isTrusted) {
+						const hackedEv = {};
+
+						for (const key in args[0]) {
+							if ("isTrusted" === key) {
+								hackedEv.isTrusted = true;
+							} else if ("function" === typeof args[0][key]) {
+								hackedEv[key] = args[0][key].bind(args[0]);
+							} else {
+								hackedEv[key] = args[0][key];
+							}
+						}
+
+						args[0] = hackedEv;
+					}
+
+					return callback.apply(callback, args);
+				};
+
+				for (const prop in callback) {
+					if ("function" === typeof callback[prop]) {
+						handler[prop] = callback[prop].bind(callback);
+					} else {
+						handler[prop] = callback[prop];
+					}
+				}
+			}
+
+			if (!this.eventListeners) {
+				this.eventListeners = {};
+			}
+			if (!this.eventListeners[type]) {
+				this.eventListeners[type] = [];
+			}
+			this.eventListeners[type].push({
+				listener: callback,
+				useCapture: options,
+				wrapped: handler,
+			});
+
+			return this._addEventListener(
+				type,
+				handler ? handler : callback,
+				options
+			);
+		};
+	}
+
+	if (!doc._removeEventListener) {
+		doc._removeEventListener = doc.removeEventListener;
+
+		doc.removeEventListener = function (type, callback, options) {
+			if ("undefined" === typeof options) {
+				options = false;
+			}
+
+			if (!this.eventListeners) {
+				this.eventListeners = {};
+			}
+			if (!this.eventListeners[type]) {
+				this.eventListeners[type] = [];
+			}
+
+			for (let i = 0; i < this.eventListeners[type].length; i++) {
+				if (
+					this.eventListeners[type][i].listener === callback &&
+					this.eventListeners[type][i].useCapture === options
+				) {
+					if (this.eventListeners[type][i].wrapped) {
+						callback = this.eventListeners[type][i].wrapped;
+					}
+
+					this.eventListeners[type].splice(i, 1);
+					break;
+				}
+			}
+
+			if (this.eventListeners[type].length == 0) {
+				delete this.eventListeners[type];
+			}
+
+			return this._removeEventListener(type, callback, options);
+		};
+	}
+}
+
+/**
+ * Revert the "wrapEventListeners" changes.
+ */
+function unwrapEventListeners() {
+	if (doc._addEventListener) {
+		doc.addEventListener = doc._addEventListener;
+		delete doc._addEventListener;
+	}
+	if (doc._removeEventListener) {
+		doc.removeEventListener = doc._removeEventListener;
+		delete doc._removeEventListener;
+	}
+	delete doc.eventListeners;
+}
diff --git a/bitburnerFiles1026/batch/batch.js b/bitburnerFiles1026/batch/batch.js
new file mode 100644
index 0000000..c5cb7f5
--- /dev/null
+++ b/bitburnerFiles1026/batch/batch.js
@@ -0,0 +1,36 @@
+import { setOfObjects } from '/batch/batcher.js';
+
+/** @param {NS} ns */
+export async function main(ns) {
+	// SINGLE BATCH RUN BY BATCHER.JS
+	// RUNS TWO WEAKENS, A GROW, AND A HACK
+	// SEPERATED BY SOME TIME
+	/*
+	Initialize the object
+
+	run weaken.js with [weaken-hack] threads
+	wait some [weakenBuffer] time
+	run weaken.js with [weakenThreadsGrow] threads
+	wait some [grow buffer] time
+	run grow.js with [grow] threads
+	wait some [hack buffer] time
+	run hack.js with [hack] threads
+	*/
+
+	// ns.disableLog("ALL");
+	// ns.clearLog();
+	// ns.tail();
+
+	let object = setOfObjects[ns.args[0]];
+
+
+	ns.exec("/batch/weaken.js", "home", Math.ceil(object.weakenThreadsHack), object.target);
+	await ns.sleep(object.weakenBuffer);
+	ns.exec("/batch/weaken.js", "home", Math.ceil(object.weakenThreadsGrow), object.target);
+	await ns.sleep(object.growBuffer);
+	ns.exec("/batch/grow.js", "home", Math.ceil(object.growThreads), object.target);
+	await ns.sleep(object.hackBuffer);
+	ns.exec("/batch/hack.js", "home", Math.ceil(object.hackThreads), object.target);
+	// ns.tprint(object.weakenThreadsHack)
+
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/batch/batcher.js b/bitburnerFiles1026/batch/batcher.js
new file mode 100644
index 0000000..e3c1546
--- /dev/null
+++ b/bitburnerFiles1026/batch/batcher.js
@@ -0,0 +1,216 @@
+// Make starting values so it won't break
+const BUFFER = 150;
+const THREADS = 100;
+const HOME = 'home';
+
+let setOfObjects = {};
+// Object is now initialized
+let object = {
+	target: {},
+	bufferTime: 100,
+
+	weakenTime: {},
+	weakenAmount: 0.05,
+
+	growTime: {},
+	growPercent: {},
+	growSecurity: {},
+
+	hackTime: {},
+	maxMoney: {},
+	hackSecurity: {},
+
+	growThreads: THREADS,
+	weakenThreadsGrow: THREADS,
+	hackThreads: THREADS,
+	weakenThreadsHack: THREADS,
+
+	weakenBuffer: {},
+	growBuffer: {},
+	hackBuffer: {}
+};
+export { setOfObjects };
+
+/** @param {NS} ns */
+export async function main(ns) {
+// RUNS BATCH.JS SCRIPTS FOR LEAST DOWNTIME
+/********************************************************************
+    * Takes as argument: server, ?("ram" || "memory")
+	*
+	* If ram or memory are the second args, just determines ram needed to use program
+	* If not, runs the sequence hack, weaken, grow, weaken with a time of [BUFFER] between each step
+	* This should (theoretically) earn the most money possible from a server
+	*
+	* Biggest downside of this program is that it needs many TB of ram (64+)
+	*
+	* run batch.js once every buffer time * 4
+	* pass the object through as an object
+	****************************************************************/
+	// ns.disableLog("ALL");
+	// ns.enableLog("sleep");
+	ns.tail();
+	ns.resizeTail(300, 130);
+	ns.moveTail(1065, 550);
+	
+	// Get the target server from the arguments passed
+	let target = ns.args[0];
+	if (target === undefined) {
+		ns.tprint("No target specified for batcher");
+		ns.exit();
+	}
+
+	// Stand idle until we can actually hack the server
+	if (ns.getHackingLevel() < ns.getServerRequiredHackingLevel(target)) {
+		while (ns.getHackingLevel() < ns.getServerRequiredHackingLevel(target)) {
+			await ns.sleep(6000);
+		}
+	}
+
+	// Make sure the security is at a minimum
+	while (ns.getServerSecurityLevel(target) > ns.getServerMinSecurityLevel(target)) {
+		ns.print("Weakening ", target);
+		ns.exec("batch/weaken.js", "home", 
+			Math.min(
+				Math.ceil((ns.getServerSecurityLevel(target) - ns.getServerMinSecurityLevel(target)) * 20), 
+				Math.floor((ns.getServerMaxRam(HOME) - ns.getServerUsedRam(HOME)) / ns.getScriptRam("batch/weaken.js"))
+			), 
+			target);
+		await ns.sleep(ns.getWeakenTime(target) + 500);
+	}
+	// Make sure the money is at a maximum
+	while (ns.getServerMoneyAvailable(target) != ns.getServerMaxMoney(target)) {
+		// Make sure the security is at a minimum
+		while (ns.getServerSecurityLevel(target) > ns.getServerMinSecurityLevel(target)) {
+			ns.print("Weakening ", target);
+			ns.exec("batch/weaken.js", "home", 
+				Math.min(
+					Math.ceil((ns.getServerSecurityLevel(target) - ns.getServerMinSecurityLevel(target)) * 20), 
+					Math.floor((ns.getServerMaxRam(HOME) - ns.getServerUsedRam(HOME)) / ns.getScriptRam("batch/weaken.js"))
+				), 
+				target);
+			await ns.sleep(ns.getWeakenTime(target) + 500);
+		}
+		ns.print("Growing ", target);
+		ns.exec("batch/grow.js", "home", 
+			Math.min(
+				Math.ceil(ns.growthAnalyze(target, ns.getServerMaxMoney(target) / (ns.getServer().moneyAvailable + 1))), 
+				Math.floor((ns.getServerMaxRam(HOME) - ns.getServerUsedRam(HOME)) / ns.getScriptRam("batch/grow.js"))
+			), 
+			target);
+		await ns.sleep(ns.getGrowTime(target) + 500);
+	}
+	// Make sure the security is at a minimum
+	while (ns.getServerSecurityLevel(target) > ns.getServerMinSecurityLevel(target)) {
+		ns.print("Weakening ", target);
+		ns.exec("batch/weaken.js", "home", 
+			Math.min(
+				Math.ceil((ns.getServerSecurityLevel(target) - ns.getServerMinSecurityLevel(target)) * 20), 
+				Math.floor((ns.getServerMaxRam(HOME) - ns.getServerUsedRam(HOME)) / ns.getScriptRam("batch/weaken.js"))
+			), 
+			target);
+		await ns.sleep(ns.getWeakenTime(target) + 500);
+	}
+
+	setOfObjects[target] = object;
+
+	setOfObjects[target].target = ns.args[0];
+	setOfObjects[target].bufferTime = BUFFER;
+
+	setOfObjects[target].weakenTime = ns.getWeakenTime(setOfObjects[target].target);
+	setOfObjects[target].weakenAmount = 0.05;
+
+	setOfObjects[target].growTime = ns.getGrowTime(setOfObjects[target].target);
+	setOfObjects[target].growPercent = ns.getServerGrowth(setOfObjects[target].target);
+	setOfObjects[target].growSecurity = ns.growthAnalyzeSecurity(1, setOfObjects[target].target, ns.getServer("home").cpuCores);
+
+	setOfObjects[target].hackTime = ns.getHackTime(setOfObjects[target].target);
+	setOfObjects[target].maxMoney = ns.getServerMaxMoney(setOfObjects[target].target);
+	setOfObjects[target].hackSecurity = ns.hackAnalyzeSecurity(1, setOfObjects[target].target);
+
+	setOfObjects[target].growThreads = 1 + ns.growthAnalyze(setOfObjects[target].target, setOfObjects[target].maxMoney / (ns.getServer().moneyAvailable + 1));
+	setOfObjects[target].weakenThreadsGrow = 10 + ((ns.growthAnalyzeSecurity(setOfObjects[target].growThreads, target, ns.getServer("home").cpuCores)) / setOfObjects[target].weakenAmount);
+	setOfObjects[target].hackThreads = 1 + ns.hackAnalyzeThreads(setOfObjects[target].target, setOfObjects[target].maxMoney);
+	setOfObjects[target].weakenThreadsHack = 10 + (ns.hackAnalyzeSecurity(setOfObjects[target].hackThreads, setOfObjects[target].target)) / setOfObjects[target].weakenAmount;
+
+	setOfObjects[target].weakenBuffer = (2 * setOfObjects[target].bufferTime);
+	setOfObjects[target].growBuffer = (setOfObjects[target].weakenTime - setOfObjects[target].bufferTime - setOfObjects[target].growTime);
+	setOfObjects[target].hackBuffer = (setOfObjects[target].growTime - (2 * setOfObjects[target].bufferTime) - setOfObjects[target].hackTime);
+
+	// if ram or memory are the second args, determine ram need to use program
+	// Ram per second { ram of each batch (batch, weaken * 2, grow, hack) divided by (BUFFER * 5 / 1000) }
+	// max ram is rate * weaken time
+	if (ns.args[1] == "ram" || ns.args[1] == "memory") {
+		ns.tprint( // Max RAM from batching this server
+			"RAM needed to batch ", target, " is ",
+			( // RAM per second
+				( // RAM per batch
+					ns.getScriptRam("/batch/batch.js") + 
+					(ns.getScriptRam("/batch/weaken.js") * setOfObjects[target].weakenThreadsGrow) + 
+					(ns.getScriptRam("/batch/weaken.js") * setOfObjects[target].weakenThreadsHack) + 
+					(ns.getScriptRam("/batch/grow.js") * setOfObjects[target].growThreads) + 
+					(ns.getScriptRam("/batch/hack.js") * setOfObjects[target].hackThreads) 
+				)
+				/
+				(
+					BUFFER * 5 / 1000
+				)
+			)
+			*
+			( // Number of seconds
+				ns.getWeakenTime(target) / 1000
+			)
+		);
+		ns.tprint(
+			"Values: ",
+			"\nbatch ram: ", ns.getScriptRam("/batch/batch.js"),
+			"\nweaken ram: ", 2 * ns.getScriptRam("/batch/weaken.js"),
+			"\ngrow ram: ", ns.getScriptRam("/batch/grow.js"),
+			"\nhack ram: ", ns.getScriptRam("/batch/hack.js"),
+			"\nRAM per batch: ", ( ns.getScriptRam("/batch/batch.js") + ns.getScriptRam("/batch/weaken.js") + ns.getScriptRam("/batch/weaken.js") + ns.getScriptRam("/batch/grow.js") + ns.getScriptRam("/batch/hack.js") ),
+			"\nPer time: ", BUFFER * 5 / 1000,
+			"\nRAM per second: ", ( // RAM per batch
+					ns.getScriptRam("/batch/batch.js") + 
+					(ns.getScriptRam("/batch/weaken.js") * setOfObjects[target].weakenThreadsGrow) + 
+					(ns.getScriptRam("/batch/weaken.js") * setOfObjects[target].weakenThreadsHack) + 
+					(ns.getScriptRam("/batch/grow.js") * setOfObjects[target].growThreads) + 
+					(ns.getScriptRam("/batch/hack.js") * setOfObjects[target].hackThreads) 
+				)
+				/
+				(
+					BUFFER * 5 / 1000
+				),
+			"\nFor ", ns.getWeakenTime(target) / 1000, " seconds"
+		);
+		ns.exit();
+	}
+
+	ns.disableLog("ALL");
+	ns.clearLog();
+
+	ns.print(target, ":");
+	ns.print("Money: ", formatLargeNumber(setOfObjects[target].maxMoney));
+	ns.print("per time: ", setOfObjects[target].bufferTime * 5);
+	ns.print("Money per second: ", formatLargeNumber(setOfObjects[target].maxMoney / (BUFFER * 5 / 1000)));
+
+	while (true) {
+		ns.exec("/batch/batch.js", "home", 1, target);
+		await ns.sleep(setOfObjects[target].bufferTime * 5);
+	}
+
+	// ns.tprint(setOfObjects[target].weakenThreadsHack);
+
+}
+
+// NOT MY CODE
+// Used to format numbers for logging
+function formatLargeNumber(number) {
+    const suffixes = ['', ' thousand', ' million', ' billion', ' trillion', ' quadrillion', ' quintillion', ' sextillion', ' septillion', ' octillion', ' nonillion', ' decillion'];
+    let suffixIndex = 0;
+
+    while (number >= 1000 && suffixIndex < suffixes.length - 1) {
+        number /= 1000;
+        suffixIndex++;
+    }
+
+    return number.toFixed(2).replace(/\.00$/, '') + suffixes[suffixIndex];
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/batch/chef.js b/bitburnerFiles1026/batch/chef.js
new file mode 100644
index 0000000..bead946
--- /dev/null
+++ b/bitburnerFiles1026/batch/chef.js
@@ -0,0 +1,13 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	let servers = ns.read("moneyServers.txt").split('\n');
+	for (let i = 0; i < servers.length; i--) {
+		ns.print(servers[i]);
+		let money = ns.getServerMaxMoney(servers[i]);
+		ns.print(money);              // Money
+		ns.print(750);                // second
+		ns.print(money * 1000 / 750); // Money per second
+		let timeLive = ns.getWeakenTime(servers[i]) + 750; // Time each batch.js is alive
+		
+	}
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/batch/grow.js b/bitburnerFiles1026/batch/grow.js
new file mode 100644
index 0000000..62f7f9d
--- /dev/null
+++ b/bitburnerFiles1026/batch/grow.js
@@ -0,0 +1,5 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	let target = ns.args[0];
+	await ns.grow(target);
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/batch/hack.js b/bitburnerFiles1026/batch/hack.js
new file mode 100644
index 0000000..e21bbb1
--- /dev/null
+++ b/bitburnerFiles1026/batch/hack.js
@@ -0,0 +1,5 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	let target = ns.args[0];
+	await ns.hack(target);
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/batch/weaken.js b/bitburnerFiles1026/batch/weaken.js
new file mode 100644
index 0000000..046cfa6
--- /dev/null
+++ b/bitburnerFiles1026/batch/weaken.js
@@ -0,0 +1,5 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	let target = ns.args[0];
+	await ns.weaken(target);
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/delete.js b/bitburnerFiles1026/delete.js
new file mode 100644
index 0000000..0ba3232
--- /dev/null
+++ b/bitburnerFiles1026/delete.js
@@ -0,0 +1,11 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	let serv = ns.args[0];
+	if (!(serv === undefined)) {
+		ns.deleteServer(serv);
+	} else {
+		ns.tprint("Server does not exist");
+	}
+}	
+
+// Take argument for which server name to delete
+\ No newline at end of file
diff --git a/bitburnerFiles1026/hack.js b/bitburnerFiles1026/hack.js
new file mode 100644
index 0000000..1a01041
--- /dev/null
+++ b/bitburnerFiles1026/hack.js
@@ -0,0 +1,51 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	// What server will be targeted?
+	let target = ns.args[0];
+	if (target === undefined) {
+		target = "iron-gym";
+	} else if (target == "help") {
+		ns.tprint("\n1st arg is target server to hack.\n2nd arg is boolean to enable debug Logs.\n");
+		ns.exit();
+	}
+
+    let debug = ns.args[1];
+	if (debug == true) {
+		ns.enableLog("weaken");
+		ns.enableLog("grow");
+		ns.enableLog("hack");
+		ns.enableLog("getServerSecurityLevel");
+		ns.enableLog("getServerMoneyAvailable");
+		ns.enableLog("getServerMaxMoney");
+		ns.enableLog("getServerMinSecurityLevel");
+	} else {
+		ns.disableLog("weaken");
+		ns.disableLog("grow");
+		ns.disableLog("hack");
+		ns.disableLog("getServerSecurityLevel");
+		ns.disableLog("getServerMoneyAvailable");
+		ns.disableLog("getServerMaxMoney");
+		ns.disableLog("getServerMinSecurityLevel");
+	}
+
+
+	//How much money does target have?
+	const moneyThresh = ns.getServerMaxMoney(target);
+
+	// When do we start hacking?
+	const securityThresh = ns.getServerMinSecurityLevel(target);
+
+	// Infinite loop that continously hacks/grows/weakens the target server
+	while (true) {
+		if (ns.getServerSecurityLevel(target) > (securityThresh + 2)) {
+			// If the server's security level is above our threshold, weaken it
+			await ns.weaken(target);
+		} else if (ns.getServerMoneyAvailable(target) < moneyThresh) {
+			// If the server's money is less than our threshold, grow it
+			await ns.grow(target);
+		} else {
+			// Otherwise, hack it
+			await ns.hack(target);
+		}
+	}
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/hacknet2.js b/bitburnerFiles1026/hacknet2.js
new file mode 100644
index 0000000..1e67b97
--- /dev/null
+++ b/bitburnerFiles1026/hacknet2.js
@@ -0,0 +1,182 @@
+const MoneyFormat = '$0.0a';
+const TimeFormat = '00:00:00';
+
+/** @param {import(".").NS } ns */
+export async function main(ns) {
+
+    /*
+    ns.hacknet-auto.script for Bitburner v0.47.2
+    Winners don't use copyright
+    
+    Latest version of this script should be at
+        https://github.com/iuriguilherme/netscripts.d
+    Bitburner should be at https://github.com/danielyxie/bitburner
+    
+    This script requires 5.70 GB of RAM to run for 1 thread(s)
+    
+    This script will buy a ns.hacknet Node, fully upgrade it and then buy the next
+    one in an infinite loop. If the cost of the next upgrade is higher than 
+    buying a new ns.hacknet Node, then a new one will be bought before the last one
+    is upgraded. There is an option to set the budget limit.
+*/
+
+	ns.tail();
+	ns.moveTail(1650, 825);
+	ns.resizeTail(250, 100);
+
+    // We will not buy anything if there's less money than this ammount
+    var reserveMoney = 2000;
+    // How many nodes to buy
+    var k = 1;
+    // Number of times to upgrade (shouldn't have to change this)
+    var n = 1;
+
+    ns.disableLog("getServerMoneyAvailable");
+    ns.disableLog("sleep");
+
+    //ns.tail();
+
+    ns.print('Waiting to purchase next upgrade...');
+
+    // Buy first ns.hacknetNode if there are none
+    if (
+        ns.hacknet.numNodes() === 0 &&
+        ns.getServerMoneyAvailable("home") >= reserveMoney
+    ) {
+        ns.hacknet.purchaseNode();
+        displayDashBoard(ns);
+    }
+
+    // If there are no ns.hacknet Nodes, we can't do anything, so the script ends.
+    while (ns.hacknet.numNodes() > 0) {
+        // If there is not enough money, we wait for it instead of ending the loop.
+        while (ns.getServerMoneyAvailable("home") >= reserveMoney) {
+            for (var i = 0; i < ns.hacknet.numNodes(); i++) {
+                while (
+                    ns.hacknet.getLevelUpgradeCost(i, n) < Infinity &&
+                    ns.hacknet.upgradeLevel(i, n)
+                ) {
+                    displayDashBoard(ns);
+                    await ns.sleep(100);
+                }
+                while (
+                    ns.hacknet.getRamUpgradeCost(i, n) < Infinity &&
+                    ns.hacknet.upgradeRam(i, n)
+                ) {
+                    displayDashBoard(ns);
+                    await ns.sleep(100);
+                }
+                while (
+                    ns.hacknet.getCoreUpgradeCost(i, n) < Infinity &&
+                    ns.hacknet.upgradeCore(i, n)
+                ) {
+                    displayDashBoard(ns);
+                    await ns.sleep(100);
+                }
+            } // END for (i = 0; i < ns.hacknet.numNodes(); i++)
+            /*
+                Buy next ns.hacknet Node if the last one is already fully upgraded.
+                If for some reason the last ns.hacknet Node is fully upgraded and the
+                others don't, the loop above will still attempt to upgrade them all.
+            */
+            if (
+                ns.hacknet.getLevelUpgradeCost((ns.hacknet.numNodes() - 1), n) === Infinity &&
+                ns.hacknet.getRamUpgradeCost((ns.hacknet.numNodes() - 1), n) === Infinity &&
+                ns.hacknet.getCoreUpgradeCost((ns.hacknet.numNodes() - 1), n) === Infinity
+            ) {
+                // Only buy nodes up to k. Past that its not really worth it.
+                if (ns.hacknet.numNodes() < k) {
+                    ns.hacknet.purchaseNode();
+
+                    displayDashBoard(ns);
+                }
+            } else if (
+                /*
+                Or buy the next ns.hacknet Node if the next upgrade is more expensive
+                than buying a new ns.hacknet Node.
+                */
+                ns.hacknet.getLevelUpgradeCost((ns.hacknet.numNodes() - 1), n) > ns.hacknet.getPurchaseNodeCost() &&
+                ns.hacknet.getRamUpgradeCost((ns.hacknet.numNodes() - 1), n) > ns.hacknet.getPurchaseNodeCost() &&
+                ns.hacknet.getCoreUpgradeCost((ns.hacknet.numNodes() - 1), n) > ns.hacknet.getPurchaseNodeCost()
+            ) {
+                if (ns.hacknet.numNodes() < 2) {
+                    ns.hacknet.purchaseNode();
+
+                    displayDashBoard(ns);
+                }
+            }
+            await ns.sleep(100);
+        }
+        await ns.sleep(100);
+    }
+};
+
+/** @param {import(".").NS } ns */
+function displayDashBoard(ns) {
+
+    ns.clearLog();
+    let nodes = Array(ns.hacknet.numNodes()).fill(0);
+    let maxNodes = ns.hacknet.numNodes() < 2 ? 2 : Infinity
+    ns.print(`Nodes: ${nodes.length} of ${maxNodes}`);
+    ns.print(`Total Production: ${nodes.length === 0 ? "$0 /s" : ns.nFormat(nodes.map((v, i) => ns.hacknet.getNodeStats(i).production).reduce((a, b) => a + b), MoneyFormat)} /s`)
+    ns.print(`Total Produced: ${nodes.length === 0 ? "$0" : ns.nFormat(nodes.map((v, i) => ns.hacknet.getNodeStats(i).totalProduction).reduce((a, b) => a + b), MoneyFormat)}`)
+    ns.print(table(
+        ["Node", "Produced", "Uptime", "Production", "Lv", "RAM", "Cores"],
+        nodes.map((v, i) => ns.hacknet.getNodeStats(i).name),
+        nodes.map((v, i) => ns.nFormat(ns.hacknet.getNodeStats(i).totalProduction, MoneyFormat)),
+        nodes.map((v, i) => ns.nFormat(ns.hacknet.getNodeStats(i).timeOnline, TimeFormat)),
+        nodes.map((v, i) => `${ns.nFormat(ns.hacknet.getNodeStats(i).production, MoneyFormat)} /s`),
+        nodes.map((v, i) => `${ns.hacknet.getNodeStats(i).level}`),
+        nodes.map((v, i) => `${ns.hacknet.getNodeStats(i).ram}`),
+        nodes.map((v, i) => `${ns.hacknet.getNodeStats(i).cores}`),
+    ));
+}
+
+const MaxReducer = (a, b) => a > b ? a : b;
+
+/**
+ * Create a Table display of the provided data
+ * @param {string[]} headers Column Headers
+ * @param  {...string[]} columns Column data
+ */
+function table(headers, ...columns) {
+    // Calculate Column Widths
+    let widths = [];
+    // for (let i = 0; i < columns.length; i++) {
+    //     widths[i] = columns[i].concat([headers[i]]).map(s => s.length).reduce(MaxReducer);
+    // }
+    columns.forEach((c, i) => {
+        widths[i] = c.concat([headers[i]]).map(s => s.length).reduce(MaxReducer);
+    });
+
+    let output = "\n";
+
+    // Write Headers
+    headers.forEach((h, i) => {
+        output += ` ${h.padEnd(widths[i], " ")} |`;
+    });
+
+    output += "\n";
+
+    // Write Separator
+    headers.forEach((h, i) => {
+        output += `${"".padEnd(widths[i] + 2, "=")}|`;
+    });
+
+    output += "\n";
+
+    let rows = columns[0].length;
+    for (let row = 0; row < rows; row++) {
+        columns.forEach((c, i) => {
+            if (c[row] == "-") {
+                output += ` ${"".padEnd(widths[i], "-")} |`;
+            } else {
+                output += ` ${c[row].padEnd(widths[i], " ")} |`;
+            }
+        });
+
+        output += "\n";
+    }
+
+    return output;
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/home.js b/bitburnerFiles1026/home.js
new file mode 100644
index 0000000..0ace136
--- /dev/null
+++ b/bitburnerFiles1026/home.js
@@ -0,0 +1,35 @@
+var money;
+
+/** @param {NS} ns */
+export async function main(ns) {
+	getmoney(ns);
+
+	ns.tail();
+	ns.moveTail(1050, 525);
+	ns.resizeTail(250, 100);
+
+	let factions = ns.getPlayer().factions;
+	ns.disableLog("disableLog");
+	ns.disableLog("clearLog");
+	ns.disableLog("sleep");
+	ns.disableLog("singularity.getUpgradeHomeRamCost");
+	ns.disableLog("singularity.getUpgradeHomeCoresCost");
+	ns.disableLog("getServerMoneyAvailable");
+	ns.clearLog();
+	while (true) {
+		getmoney(ns);
+		if (money > ns.singularity.getUpgradeHomeRamCost()) {
+			ns.singularity.upgradeHomeRam();
+		} else if (money > ns.singularity.getUpgradeHomeCoresCost()) {
+			ns.singularity.upgradeHomeCores();
+		} else if (ns.singularity.checkFactionInvitations().length > 0) {
+			ns.singularity.joinFaction(ns.singularity.checkFactionInvitations()[0]);
+		} 
+		await ns.sleep(1000);
+	}
+}
+
+
+function getmoney(ns) {
+	money = ns.getServerMoneyAvailable("home");
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/hwgw/hacker.js b/bitburnerFiles1026/hwgw/hacker.js
new file mode 100644
index 0000000..c4c827b
--- /dev/null
+++ b/bitburnerFiles1026/hwgw/hacker.js
@@ -0,0 +1,255 @@
+let growhost = ["home"]; // Initialize the growhost array -- Include "home" if you want to grow servers from home as well as pservs
+let targets;
+let full = false;
+let grown = [];
+let running = [];
+const debug = false; // True to print debugging logs
+let hostmax = 25; // Set the maximum number of hosts -- Useful for changing between using home and not
+
+/** @param {NS} ns */
+export async function main(ns) {
+	const hackram = ns.getScriptRam("temphack.js");
+	const growram = ns.getScriptRam("tempgrow.js");
+	if (ns.args[0] == "-f") {
+		full = true;
+	}
+
+	ns.tail();
+	ns.moveTail(1075, 350);
+	ns.resizeTail(300, 200);
+
+	ns.tail();
+	if (!debug) {ns.disableLog("ALL")}
+	if (debug) {ns.disableLog("sleep")}
+
+	targets = Array(ns.read("moneyServers.txt"))[0].split("\n");
+	
+	if (debug) {ns.print("Line 27")}
+	for (let i = targets.length - 1; i >= 0; i--) {
+		if (ns.getRunningScript("temphack.js", "home", targets[i], true)) {
+			ns.print("Already running ", targets[i]);
+			running.push(targets[i]);
+		}
+		await ns.sleep(100);
+	}
+	
+	gethosts(ns);
+
+	if (debug) {ns.print("Line 38")}
+	// if (growhost.length < 5) {
+	// 	ns.print("waiting for pservs");
+	// 	while (growhost.length < 5) {
+	// 		gethosts(ns);
+	// 		await ns.sleep(1000);
+	// 	}
+	// 	ns.print("done waiting for pservs");
+	// }
+	
+	if (debug) {ns.print("Line 48")}
+	let m = false;
+	if (growhost.length == 1 || growhost.length == 0) {
+		ns.print("Growhost length:", growhost.length);
+		ns.exec("hack.js", "home", Math.floor((ns.getServerMaxRam("home") - ns.getServerUsedRam("home")) / ns.getScriptRam("hack.js")), "foodnstuff", true);
+		m = true;
+	}
+
+	if (debug) {ns.print("Line 56")}
+	if (m == true) {
+		ns.kill("hack.js", "home", "foodnstuff", true);
+	}
+
+	// Wait until we have FTPCrack.exe
+	// if (!ns.fileExists("FTPCrack.exe")) {
+	// 	ns.print("Waiting for FTPCrack.exe");
+	// 	while (!ns.fileExists("FTPCrack.exe")) {
+	// 		await ns.sleep(6000);
+	// 	}
+	// }
+	
+	// Main Loop
+	let n = 0;
+	while (n < targets.length) {
+		if (debug) {ns.print("Beginning of loop")}
+		n = 0;
+
+		// Check for new pserv's
+		if (growhost.length < 25) {
+			gethosts(ns);
+		}
+
+		// correct grown[] by reseting and counting all that are currently being grown
+		// so that they can be hacked afterward
+		grown = [];
+		if (debug) {ns.print("Before first for loop"); ns.print("Growhost length: ", growhost.length); ns.print("Targets length: ", targets.length)}
+		for (let i = 0; i < growhost.length; i++) {
+			for (let j = 0; j < targets.length; j++) {
+				if (debug) {ns.clearLog(); ns.print("Checking grown  ", i, ":", j)}
+				if (ns.getRunningScript("tempgrow.js", growhost[i], targets[j])) {
+					grown.push(targets[j]);
+				}
+				await ns.sleep(10);
+			}
+			await ns.sleep(100);
+		}
+
+		running = [];
+		if (debug) {ns.print("Before second for loop")}
+		for (let i = targets.length - 1; i >= 0; i--) {
+			if (ns.getRunningScript("temphack.js", "home", targets[i], true)) {
+				ns.print("Already running ", targets[i]);
+				running.push(targets[i]);
+			}
+			await ns.sleep(100);
+		}
+
+		
+		if (debug) {ns.print("Targets: ");ns.print(targets);ns.print("Before third for loop")}
+		for (let i = targets.length - 1; i >= 0; i--) { // for every target, going backwards from most to least money
+		// for (let i = 0; i < targets.length; i++) { // for every target, going backwards from most to least money
+			if (!grown.includes(targets[i]) && !running.includes(targets[i])) { // not running or grown
+				// ns.print("Don't have ", targets[i], " running");
+				let hacklevel = ns.getHackingLevel() * 0.9; // get the player's hacking level
+				if (hacklevel >= ns.getServerRequiredHackingLevel(targets[i])) { // when the target is hackable
+					if (!ns.hasRootAccess(targets[i])) { // if we don't have access
+						ns.print(i + 1, ": ", targets[i], "\n");
+						ns.brutessh(targets[i]);
+						try {
+							ns.ftpcrack(targets[i]);
+							ns.relaysmtp(targets[i]);
+							ns.httpworm(targets[i]);
+							ns.sqlinject(targets[i]);
+						} catch {}
+						try {
+							ns.nuke(targets[i]);
+							ns.print("Gained root access to ", targets[i]);
+						} catch {
+							continue;
+						}
+					}
+					if (ns.getServerMoneyAvailable(targets[i]) != ns.getServerMaxMoney(targets[i])) { // if it needs to be grown
+						let host = ghost(ns);
+						ns.print("Host: ", host);
+						if (!ns.getRunningScript("tempgrow.js", host, targets[i])) {
+							ns.print("Host: ", host);
+							let threads = growthreads(ns, targets[i]);
+							if (threads * growram > netram(ns, host)) {
+								threads = Math.floor(netram(ns, host) / growram);
+							}
+							ns.print("Host: ", host);
+							if (threads > 0) {
+								ns.print("Growing ", targets[i]);
+								ns.exec("tempgrow.js", host, threads, targets[i]);
+								grown.push(targets[i]);
+								break;
+							}
+						}
+					} else { // if it can now be hacked
+						let threads = hackthreads(ns, targets[i]);
+						let host = "home"
+						if (threads * hackram < netram(ns, host)) {
+							if (threads > 0) {
+								ns.print("Threads for: ", targets[i], ", ", hackthreads(ns, targets[i]), "\n");
+								ns.exec("temphack.js", "home", threads, targets[i], true);
+								running.push(targets[i]);
+							}
+						} else {
+							host = ghost(ns);
+							if (threads * hackram > netram(ns, host)) {
+								threads = Math.floor(netram(ns, host) / hackram);
+							}
+							if (threads > 0) {
+								ns.exec("temphack.js", host, threads, targets[i], true);
+								running.push(targets[i]);
+							}
+						}
+					}
+				}
+			}
+			await ns.sleep(100);
+		}
+		if (debug) {ns.print("End of loop")}
+		display(ns);
+		await ns.sleep(100);
+	}
+	ns.tprint("All targets grown and being hacked");
+}
+
+function netram(ns, serv) {
+	ns.print("netram");
+	return ns.getServerMaxRam(serv) - ns.getServerUsedRam(serv);
+}
+
+// Finds the minimum number of threads to hack a target server
+function hackthreads(ns, serv) {
+	ns.print("hackthreads");
+	try {
+		return Math.ceil(1 / (ns.formulas.hacking.hackPercent(ns.getServer(serv), ns.getPlayer())));
+	} catch {
+		return 1000
+	}
+}
+
+function ghost(ns) {
+	ns.print("ghosts");
+	for (let i = 0; i < growhost.length; i++) {
+		if (ns.getServerUsedRam(growhost[i]) == 0) {
+			return growhost[i];
+		}
+	}
+	for (let i = 0; i < growhost.length; i++) {
+		if (netram(ns, growhost[i]) > 2000) {
+			return growhost[i];
+		}
+	}
+	return growhost[0];
+}
+
+function growthreads(ns, serv) {
+	ns.print("growthreads");
+	try {
+		return Math.max(
+			(ns.formulas.hacking.growThreads(ns.getServer(serv), ns.getPlayer(), ns.getServerMaxMoney(serv))) * 2,
+			Math.ceil((ns.getServerSecurityLevel(serv) - ns.getServerMinSecurityLevel(serv)) / 0.05)
+		);
+	} catch {
+		return 500;
+	}
+}
+
+function gethosts (ns) {
+	ns.print("gethosts");
+	for (let s = growhost.length - 1; s < 25; s++) {
+		if (s < 10) {
+			if (ns.serverExists("pserv-0" + s) && !growhost.includes("pserv-0" + s)) {
+				growhost.push("pserv-0" + s);
+				ns.scp("tempgrow.js", growhost[growhost.length - 1]);
+				ns.scp("temphack.js", growhost[growhost.length - 1]);
+			}
+		} else {
+			if (ns.serverExists("pserv-" + s) && !growhost.includes("pserv-" + s)) {
+				growhost.push("pserv-" + s);
+				ns.scp("tempgrow.js", growhost[growhost.length - 1]);
+				ns.scp("temphack.js", growhost[growhost.length - 1]);
+			}
+		}
+	}
+}
+
+function display(ns) {
+	ns.clearLog();
+	for (let i = 0; i < targets.length; i++) {
+		if (ns.getRunningScript("temphack.js", "home", targets[i], true)) {
+			ns.print(targets[i], ": Running\n");
+		} else if (full == true) {
+			ns.print(targets[i], ": Idle\n");
+		} else {
+			for (let j = 0; j < growhost.length; j++) {
+				if (ns.getRunningScript("tempgrow.js", growhost[j], targets[i])) {
+					ns.print(targets[i], ": Growing\n");
+					break;
+				}
+			}
+		}
+	}
+	ns.print("Growhosts: ", growhost.length);
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/install.js b/bitburnerFiles1026/install.js
new file mode 100644
index 0000000..ecbe449
--- /dev/null
+++ b/bitburnerFiles1026/install.js
@@ -0,0 +1,4 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	ns.singularity.installAugmentations("start.js");
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/liquidate.js b/bitburnerFiles1026/liquidate.js
new file mode 100644
index 0000000..79f902e
--- /dev/null
+++ b/bitburnerFiles1026/liquidate.js
@@ -0,0 +1,10 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	const syms = ns.stock.getSymbols();
+	ns.scriptKill("stocks.js", "home");
+	ns.scriptKill("stocker.js", "home");
+	for (let i = 0; i < syms.length; i++) {
+		let shares = ns.stock.getMaxShares(syms[i]);
+		ns.stock.sellStock(syms[i], shares);
+	}
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/maxprice.txt b/bitburnerFiles1026/maxprice.txt
new file mode 100644
index 0000000..58e8fae
--- /dev/null
+++ b/bitburnerFiles1026/maxprice.txt
@@ -0,0 +1 @@
+921.2475880659246
+\ No newline at end of file
diff --git a/bitburnerFiles1026/milestones.js b/bitburnerFiles1026/milestones.js
new file mode 100644
index 0000000..856900a
--- /dev/null
+++ b/bitburnerFiles1026/milestones.js
@@ -0,0 +1,133 @@
+const HOME = "home";
+
+// You have to run this script once per target
+
+let hacked = [];
+
+/** @param {NS} ns */
+export async function main(ns) {
+	
+	ns.tail();
+	ns.moveTail(1650, 725);
+	ns.resizeTail(250, 100);
+
+	ns.disableLog("disableLog");
+	ns.disableLog("clearLog");
+	ns.disableLog("sleep");
+	ns.disableLog("scan");
+	ns.clearLog();
+	
+	const targets = [
+		"CSEC",
+		"avmnite-02h",
+		"I.I.I.I",
+		"run4theh111z"//,
+		// "w0r1d_d43m0n"
+	];
+
+	while (!ns.fileExists("SQLInject.exe")) {
+		await ns.sleep(12000);
+	}
+	for (let i = 0; i < targets.length; i++) {
+		if (targets[i] == "w0rld_d43m0n") {
+			while (!ns.singularity.getOwnedAugmentations().includes("The Red Pill")) {
+				ns.clearLog();
+				ns.print("Waiting for red pill");
+				await ns.sleep(60000);
+			}
+		}
+		await root(ns, targets[i]);
+	}
+}
+function buildRoute(ns, parent, target, route, seen = []) {
+    //first time we run we need to add the parent to the list of servers we've seen
+    if (!seen.includes(parent)) {
+        seen.push(parent);
+	}
+    //add to route
+    route.push(parent);
+    const children = ns.scan(parent);
+    for (const child of children) {
+        if (seen.includes(child)) {
+            //already checked
+            continue;
+        }
+        seen.push(child);
+        if (child == target) {
+            //found target, add it to the route and finish recursion
+            route.push(child);
+            return true;
+        }
+        if (buildRoute(ns, child, target, route, seen)) {
+            //target found, finish recursion
+            return true;
+        }
+        else {
+            //target not found in this branch, remove from route
+            route.pop();
+        }
+    }
+    //didn't find target in this route, reset route
+    route = [];
+    return false;
+}
+async function printRoute(ns, route) {
+    let result = [];
+    for (const node of route) {
+        result.push(node);
+    }
+    return result;
+}
+async function root(ns, target) {
+	if (!ns.hasRootAccess(target)) {
+		ns.brutessh(target);
+		ns.ftpcrack(target);
+		ns.relaysmtp(target);
+		ns.httpworm(target);
+		ns.sqlinject(target);
+		ns.print("Gained root access to ", target);
+		while (ns.getHackingLevel() < ns.getServerRequiredHackingLevel(target)) {
+			await ns.sleep(6000);
+		}
+		ns.nuke(target);
+
+		ns.singularity.connect(HOME);
+		await ns.sleep(100);
+
+		let result = [];
+		let route = [];
+
+		buildRoute(ns, HOME, target, route)
+		result = await printRoute(ns, route);
+
+		for (let n = 0; n < result.length; n++) {
+			ns.singularity.connect(result[n]);
+			await ns.sleep(100);
+		}
+		await ns.singularity.installBackdoor();
+		ns.singularity.connect(HOME);
+	} else if (!ns.getServer(target).backdoorInstalled) {
+		ns.singularity.connect(HOME);
+		await ns.sleep(100);
+
+		let result = [];
+		let route = [];
+		
+		buildRoute(ns, HOME, target, route)
+		result = await printRoute(ns, route);
+		
+		for (let n = 0; n < result.length; n++) {
+			ns.singularity.connect(result[n]);
+			await ns.sleep(100);
+		}
+		await ns.singularity.installBackdoor();
+		ns.singularity.connect(HOME);
+	}
+	hacked.push(target);
+	ns.clearLog();
+	ns.print("Hacked servers: ", )
+	for (let j = 0; j < hacked.length; j++) {
+		ns.print(hacked[j]);
+	}
+	return 0;
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/minprice.txt b/bitburnerFiles1026/minprice.txt
new file mode 100644
index 0000000..123c27c
--- /dev/null
+++ b/bitburnerFiles1026/minprice.txt
@@ -0,0 +1 @@
+526.5046927941131
+\ No newline at end of file
diff --git a/bitburnerFiles1026/moneyServers.txt b/bitburnerFiles1026/moneyServers.txt
new file mode 100644
index 0000000..c21cf03
--- /dev/null
+++ b/bitburnerFiles1026/moneyServers.txt
@@ -0,0 +1,63 @@
+n00dles
+foodnstuff
+sigma-cosmetics
+joesguns
+hong-fang-tea
+harakiri-sushi
+iron-gym
+nectar-net
+max-hardware
+zer0
+neo-net
+phantasy
+silver-helix
+omega-net
+netlink
+johnson-ortho
+crush-fitness
+the-hub
+computek
+syscore
+catalyst
+zb-institute
+summit-uni
+rothman-uni
+lexo-corp
+aevum-police
+rho-construction
+alpha-ent
+millenium-fitness
+global-pharm
+snap-fitness
+galactic-cyber
+aerocorp
+omnia
+deltaone
+unitalife
+defcomm
+solaris
+zeus-med
+icarus
+univ-energy
+infocomm
+taiyang-digital
+nova-med
+zb-def
+titan-labs
+applied-energetics
+microdyne
+fulcrumtech
+stormtech
+helios
+vitalife
+omnitek
+kuai-gong
+4sigma
+b-and-a
+nwo
+blade
+clarkinc
+powerhouse-fitness
+ecorp
+megacorp
+fulcrumassets
+\ No newline at end of file
diff --git a/bitburnerFiles1026/monitor.js b/bitburnerFiles1026/monitor.js
new file mode 100644
index 0000000..50cf4a4
--- /dev/null
+++ b/bitburnerFiles1026/monitor.js
@@ -0,0 +1,63 @@
+import { setOfObjects } from "/batch/batcher.js"
+
+// Monitors the specified server, process, or the player's cash
+// [Server] monitors the server's security level and available cash
+// "money" or "cash" does nothing :3
+// "batcher" displays the maximum cash for the servers found in Arr, rounded to multiples of 1 billion
+
+
+/** @param {NS} ns */
+export async function main(ns) {
+	ns.tail();
+
+	ns.disableLog("ALL");
+
+	const target = ns.args[0];
+
+	if (target === undefined) {
+		ns.print("No target specified\nExiting...");
+		ns.exit();
+	}
+
+	if (target == "deltaone") {
+
+		// let server = ns.getServer();
+		while (true) {
+			ns.clearLog();
+			
+			ns.print("Security: ", Math.round(ns.getServerSecurityLevel(target)), " / ", ns.getServerMinSecurityLevel(target));
+			ns.print("Money: ", Math.round(ns.getServerMoneyAvailable(target)), " / ", Math.round(ns.getServerMaxMoney(target)));
+			await ns.sleep(500);
+		}
+	} else if (target == "money" || target == "cash") {
+		let last = ns.getPlayer().money;
+		await ns.sleep(1000);
+		let total = ns.getPlayer().money;
+		while (true) {
+			ns.clearLog();
+			
+			await ns.sleep(1000);
+		}
+	} else if (target == "batcher") {
+		while (true) {
+			ns.clearLog();
+			let arr = [
+				'zb-institute',
+				'galactic-cyber',
+				'aerocorp',
+				'omnia',
+				'deltaone',
+				'taiyang-digital',
+				'icarus',
+				'zeus-med',
+				'infocomm',
+				'solaris',
+				'defcomm'
+			];
+			for (let i = 0; i < arr.length; i++) {
+				ns.print(arr[i], ": ", (ns.getServerMaxMoney(arr[i]) / 1e9).toFixed(3));
+			}
+			await ns.sleep(1000);
+		}
+	}
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/root.js b/bitburnerFiles1026/root.js
new file mode 100644
index 0000000..d04449e
--- /dev/null
+++ b/bitburnerFiles1026/root.js
@@ -0,0 +1,358 @@
+const HOME = "home";
+
+/** @param {NS} ns */
+export async function main(ns) {
+    let target = "home";
+    let thread = 1;
+    const scriptRam = 2.4;
+
+    // Determine whether or not to enable logging
+    let debug = ns.args[0];
+    ns.disableLog("ALL");
+
+    // What percentage of our hacking level should a server be before using it
+    let lvlpercent = ns.args[1];
+
+    // List of targets for each level of exe function
+    const targets = [
+        "deltaone",
+        "global-pharm",
+        "rho-construction",
+        "the-hub",
+        "iron-gym",
+        "harakiri-sushi"
+    ];
+
+    // List of exe functions
+    const exes = [
+        "SQLInject.exe",
+        "HTTPWorm.exe",
+        "RelaySMTP.exe",
+        "FTPCrack.exe",
+        "BruteSSH.exe",
+        "NUKE.exe"
+    ];
+
+    // Array of all purchased servers
+    //  Varying RAM sizes
+    const pservers = [
+        "pserv-0",
+        "pserv-1",
+        "pserv-2",
+        "pserv-3",
+        "pserv-4",
+        "pserv-5",
+        "pserv-6",
+        "pserv-7",
+        "pserv-8",
+        "pserv-9",
+        "pserv-10",
+        "pserv-11",
+        "pserv-12",
+        "pserv-13",
+        "pserv-14",
+        "pserv-15",
+        "pserv-16",
+        "pserv-17",
+        "pserv-18",
+        "pserv-19",
+        "pserv-20",
+        "pserv-21",
+        "pserv-22",
+        "pserv-23",
+    ];
+
+
+    // Array of all servers that don't need any ports opened
+    // to gain root access. These have  GB of RAM
+    const servers0Port = [
+        "n00dles",
+        "foodnstuff",
+        "sigma-cosmetics",
+        "joesguns",
+        "nectar-net",
+        "hong-fang-tea",
+        "harakiri-sushi"
+    ];
+
+
+    // Array of all servers that only need 1 port opened
+    // to gain root access. These have 32 GB of RAM
+    const servers1Port = [
+        "neo-net",
+        "zer0",
+        "max-hardware",
+        "iron-gym",
+        "CSEC"
+    ];
+
+
+    // 2 port servers
+    const servers2Port = [
+        "omega-net",
+        "silver-helix",
+        "phantasy",
+        "johnson-ortho",
+        "crush-fitness",
+        "the-hub",
+        "avmnite-02h"
+    ];
+
+    // 3 port servers
+    const servers3Port = [
+        "netlink",
+        "computek",
+        "I.I.I.I",
+        "summit-uni",
+        "catalyst",
+        "rothman-uni",
+        "millenium-fitness",
+        "rho-construction"
+    ];
+
+    const servers4Port = [
+        "aevum-police",
+        "global-pharm",
+        "syscore",
+        "lexo-corp",
+        "unitalife",
+        "snap-fitness",
+        "alpha-ent",
+        "univ-energy",
+        "nova-med",
+        "zb-def"
+    ];
+
+    // 5 port servers
+    const servers5Port = [
+        "zb-institute",
+        "galactic-cyber",
+        "aerocorp",
+        "omnia",
+        "deltaone",
+        "taiyang-digital",
+        "icarus",
+        "zeus-med",
+        "infocomm",
+        "solaris",
+        "defcomm"
+    ];
+    
+    // //decide the target
+    // // Cycle through each .exe file for a match
+    // for (let i = 0; i < exes.length; i++) {
+    //     // if the file doens't exist yet, look at the next file
+    //     if (ns.fileExists(exes[i]) && (ns.getServerRequiredHackingLevel(targets[i]) <= (ns.getHackingLevel() * lvlpercent))) {
+    //         // the file exists, so the target is now the best target of that file
+    //         target = targets[i];
+    //         break;
+    //     }
+    // }
+    // // List the target in the logs
+    // ns.print("target: ", target);
+    // root(ns, target);
+
+    // // Hack from the home server
+    // if (ns.serverExists("home")) {
+    //     const serv = "home";
+    //     ns.print("Hacking using: ", serv);
+    //     thread = threads(ns, serv, scriptRam, thread);
+    //     if (thread > 0) {
+    //         hax(ns, serv, target, thread, true);
+    //     }
+    // }
+
+    // // DEBUGGING: uncomment the following line to find logs for the above code
+    // if (debug) {
+    //     await ns.sleep(60000);
+    // }
+    // // Copy our scripts onto each server that requires 0 ports
+    // // to gain root access. Then use nuke() to gain admin access and
+    // // run the scripts.
+    // for (let i = 0; i < servers0Port.length; ++i) {
+    //     const serv = servers0Port[i];
+    //     ns.print("Hacking using: ", serv);
+    //     root(ns, serv);
+    //     thread = threads(ns, serv, scriptRam, thread);
+    //     if (thread > 0) {
+    //         hax(ns, serv, target, thread, debug);
+    //     }
+    // }
+
+    // // Wait until we acquire the "BruteSSH.exe" program
+    // if (!ns.fileExists("BruteSSH.exe")) {
+    //     ns.print("Waiting for BruteSSH.exe");
+    //     ns.exit();
+    // }
+
+    // // Copy our scripts onto each server that requires 1 port
+    // // to gain root access. Then use brutessh() and nuke()
+    // // to gain admin access and run the scripts.
+    // for (let i = 0; i < servers1Port.length; ++i) {
+    //     const serv = servers1Port[i];
+
+    //     ns.print("Hacking using: ", serv);
+    //     root(ns, serv);
+    //     thread = threads(ns, serv, scriptRam, thread);
+    //     if (thread > 0) {
+    //         hax(ns, serv, target, thread, debug);
+    //     }
+    // }
+
+    // // Wait until we acquire the "BruteSSH.exe" program
+    // while (!ns.fileExists("FTPCrack.exe")) {
+    //     ns.print("Waiting for FTPCrack");
+    //     ns.exit();
+    // }
+
+    // // Copy our scripts onto each server that requires 1 port
+    // // to gain root access. Then use brutessh() and nuke()
+    // // to gain admin access and run the scripts.
+    // for (let i = 0; i < servers2Port.length; ++i) {
+    //     const serv = servers2Port[i];
+
+    //     ns.print("Hacking using: ", serv);
+    //     root(ns, serv);
+    //     thread = threads(ns, serv, scriptRam, thread);
+    //     if (thread > 0) {
+    //         hax(ns, serv, target, thread, debug);
+    //     }
+    // }
+
+
+    // //Run hack scripts from purchased servers
+    // for (let i = 0; i < pservers.length; ++i) {
+    //     while (!ns.serverExists(pservers[i])) {
+    //         ns.print("Server ", pservers[i], " doesn't exist yet");
+    //         await ns.sleep(60000);
+    //     }
+    //     const serv = pservers[i];
+
+    //     ns.print("Hacking using: ", serv);
+    //     thread = threads(ns, serv, scriptRam, thread);
+    //     if (thread > 0) {
+    //         hax(ns, serv, target, thread, debug);
+    //     }
+    // }
+
+    // while (!ns.fileExists("RelaySMTP.exe")) {
+    //     ns.print("Waiting for RelaySMTP");
+    //     ns.exit();
+    // }
+
+    // for (let i = 0; i < servers3Port.length; ++i) {
+    //     const serv = servers3Port[i];
+
+    //     ns.print("Hacking using: ", serv);
+    //     root(ns, serv);
+    //     thread = threads(ns, serv, scriptRam, thread);
+    //     if (thread > 0) {
+    //         hax(ns, serv, target, thread, debug);
+    //     }
+    // }
+
+    const servers = [
+        servers0Port,
+        servers1Port,
+        servers2Port,
+        servers3Port,
+        servers4Port,
+        servers5Port,
+    ];
+
+    let hacked = [];
+
+    ns.clearLog();
+    ns.tail();
+    ns.moveTail(0,0);
+    ns.resizeTail(1350, 600);
+    ns.print("DONT DO ANYTHING DONT DO ANYTHING DONT DO ANYTHING DONT DO ANYTHING \n\n\n\n\n\n\n\n\n\n\n\n");
+    await ns.sleep(1000);
+
+    for (let i = 0; i < servers.length; i++) {
+        for (let j = 0; j < servers[i].length; j++) {
+            if (!ns.hasRootAccess(servers[i][j])) {
+                ns.brutessh(servers[i][j]);
+                ns.ftpcrack(servers[i][j]);
+                ns.relaysmtp(servers[i][j]);
+                ns.httpworm(servers[i][j]);
+                ns.sqlinject(servers[i][j]);
+                while (ns.getHackingLevel() < ns.getServerRequiredHackingLevel(servers[i][j])) {
+                    await ns.sleep(6000);
+                }
+                ns.nuke(servers[i][j]);
+                ns.print("Gained root access to ", servers[i][j]);
+            }
+            if (!ns.getServer(servers[i][j]).backdoorInstalled) {
+                ns.singularity.connect(HOME);
+                await ns.sleep(100);
+
+                let result = [];
+                let route = [];
+                
+                buildRoute(ns, HOME, servers[i][j], route)
+                result = await printRoute(ns, route);
+                
+                for (let n = 0; n < result.length; n++) {
+                    ns.singularity.connect(result[n]);
+                    await ns.sleep(100);
+                }
+                await ns.singularity.installBackdoor();
+                ns.singularity.connect(HOME);
+            }
+            hacked.push(servers[i][j]);
+        }
+    }
+
+    await ns.sleep(1000);
+    ns.clearLog();
+    ns.moveTail(500, 300);
+    ns.resizeTail(300, 100);
+    ns.print("Backdoors installed");
+
+
+
+}
+
+function buildRoute(ns, parent, target, route, seen = []) {
+    //first time we run we need to add the parent to the list of servers we've seen
+    if (!seen.includes(parent)) {
+        seen.push(parent);
+	}
+    //add to route
+    route.push(parent);
+    const children = ns.scan(parent);
+    for (const child of children) {
+        if (seen.includes(child)) {
+            //already checked
+            continue;
+        }
+        seen.push(child);
+        if (child == target) {
+            //found target, add it to the route and finish recursion
+            route.push(child);
+            return true;
+        }
+        if (buildRoute(ns, child, target, route, seen)) {
+            //target found, finish recursion
+            return true;
+        }
+        else {
+            //target not found in this branch, remove from route
+            route.pop();
+        }
+    }
+    //didn't find target in this route, reset route
+    route = [];
+    return false;
+}
+async function printRoute(ns, route) {
+    let result = [];
+    for (const node of route) {
+        result.push(node);
+    }
+    return result;
+}
+function root(ns, target) {
+	
+}
diff --git a/bitburnerFiles1026/route.js b/bitburnerFiles1026/route.js
new file mode 100644
index 0000000..97d814a
--- /dev/null
+++ b/bitburnerFiles1026/route.js
@@ -0,0 +1,57 @@
+const HOME = "home";
+let target;
+export async function main(ns) {
+    let result = [];
+    let route = [];
+    let seen = [];
+    target = ns.args[0]; // The target server
+    let backdoor = ns.args[1]; // True for connecting to the server and backdooring
+    if (target === undefined) {
+        ns.tprint("No target server specified");
+        ns.exit();
+    }
+    if (buildRoute(ns, HOME, route, seen)) {
+        result = await printRoute(ns, route);
+    }
+}
+function buildRoute(ns, parent, route, seen) {
+    //first time we run we need to add the parent to the list of servers we've seen
+    if (!seen.includes(parent))
+        seen.push(parent);
+    //add to route
+    route.push(parent);
+    const children = ns.scan(parent);
+    for (const child of children) {
+        if (seen.includes(child)) {
+            //already checked
+            continue;
+        }
+        seen.push(child);
+        if (child == target) {
+            //found  add it to the route and finish recursion
+            route.push(child);
+            return true;
+        }
+        if (buildRoute(ns, child, route, seen)) {
+            //target found, finish recursion
+            return true;
+        }
+        else {
+            //target not found in this branch, remove from route
+            route.pop();
+        }
+    }
+    //didn't find target in this route, reset route
+    route = [];
+    return false;
+}
+async function printRoute(ns, route) {
+    let result = [];
+    for (const node of route) {
+        result.push(node);
+    }
+    result.push('backdoor');
+    // await navigator.clipboard.writeText(result);
+    ns.tprint(result);
+    return result;
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/run.js b/bitburnerFiles1026/run.js
new file mode 100644
index 0000000..31c70cd
--- /dev/null
+++ b/bitburnerFiles1026/run.js
@@ -0,0 +1,12 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	const target = ns.args[0];
+	const script = ns.args[1];
+	const scriptRam = ns.getScriptRam(script);
+	ns.exec(script, "home", threads(ns, scriptRam), target);
+	await ns.sleep(4000);
+}
+
+function threads(ns, scriptRam) {
+    return Math.floor(((ns.getServerMaxRam("home") - ns.getServerUsedRam("home")) * 0.95) / scriptRam);
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/scripts.txt b/bitburnerFiles1026/scripts.txt
new file mode 100644
index 0000000..e636a8a
--- /dev/null
+++ b/bitburnerFiles1026/scripts.txt
@@ -0,0 +1,31 @@
+start.js 
+	(hacknet2.js) runs hacknet, 
+	(root.js) hacks a single server using all servers (inefficient), 
+	(servers.js) purchases all pservs, 
+	stocker.js (ineffiecient)
+
+hwgw/hacker.js 
+	hacks every server
+
+autoinfiltrate.js
+	run to enable automatic infiltration of companies
+
+delete.js
+	deletes a currently owned pserv
+
+liquidate.js
+	sells all stocks
+
+master.js
+	singularity api testing script
+	controls all things from the singularity api
+
+run.js
+	runs a script on a server at the maximum threads possible
+
+target.js
+	finds the target server with the most money for a given port level
+
+targets.js
+	finds all servers with money on them
+
diff --git a/bitburnerFiles1026/servers.js b/bitburnerFiles1026/servers.js
new file mode 100644
index 0000000..af82de7
--- /dev/null
+++ b/bitburnerFiles1026/servers.js
@@ -0,0 +1,134 @@
+
+//	enter ram size, number of servers, upgrade yes or no.
+
+
+/** @param {NS} ns */
+export async function main(ns) {
+	const HOME = "home";
+	let size = ns.args[0];      // int;  home many GB of ram to buy			standard: 2048
+	let number = ns.args[1];    // int;  how many pservs to obtain			standard: "max"
+	const upgrade = ns.args[2]; // bool; does it upgrade existing pservs	standard: true
+	const debug = ns.args[3];   // bool; does it log what happens			standard: false
+	const LIMIT = 64000;     // sets the max on how much ram a pserv can have (64 TB)
+
+	if (size == "--help") {
+		ns.tprint("\n 1st arg is the Ram size of the servers; does not do anything if upgrade is true; Mandatory.\n 2nd arg is the number of servers; does not do anything if upgrade is true; default to 24.\n 3rd arg is whether to continously upgrade servers; default to false.\n 4th arg is whether to enable debug logs; default is false.");
+		ns.exit();
+	}
+	if (debug != true) {
+		ns.disableLog("getServerMaxRam");
+		ns.disableLog("sleep");
+		ns.disableLog("getServerMoneyAvailable");
+	}
+	
+	if (size === undefined) {
+		ns.print("Arguments for this script are RAM size of the servers, number of servers, and true or false for if existing servers should be upgraded.");
+		ns.exit();
+	} else if (Math.log2(size) % 1 != 0) {
+		ns.print("The RAM size must be a power of two.");
+		ns.exit();
+	} else if (number === undefined) {
+		number = 1;
+	} if (number > 25 || number == "max") {
+		number = 25;
+		ns.print("The Maximum number of servers is 25. Reverting to 25 servers");
+	}
+
+	if (upgrade) {
+		const homeram = ns.getServerMaxRam(HOME);
+		let fullservs = 0;
+		while (fullservs < 24) {
+			// start a for loop that goes through each server name
+			for (let i = 0; i < number; i++) {
+				// set the server name
+				let serv;
+				if (i < 10) {
+					serv = "pserv-0" + i;
+				} else {
+					serv = "pserv-" + i;
+				}
+				// check if the server already exists, if it does, upgrade it up to 1/2 of home
+				if (ns.serverExists(serv)) {
+					let servram = ns.getServerMaxRam(serv);
+					// upgrading until server ram is 1/2 home ram
+					if (servram < LIMIT) {
+						// wait to upgrade the server until we have enough money
+						if (ns.getPurchasedServerUpgradeCost(serv, servram * 2) > ns.getServerMoneyAvailable(HOME)) {
+								ns.print("Not enough money yet to upgrade ", serv);
+								ns.print("Need ", ns.getPurchasedServerUpgradeCost(serv, servram * 2), " to upgrade ", serv);
+							while (ns.getPurchasedServerUpgradeCost(serv, servram * 2) > ns.getServerMoneyAvailable(HOME)) {
+								await ns.sleep(60000);
+							}
+						}
+						ns.print("Upgrading ", serv, " from ", servram, " to ", servram * 2);
+						ns.upgradePurchasedServer(serv, servram * 2);
+					}
+				} else {
+					// wait to buy the server until we have enough money
+					while (ns.getPurchasedServerCost(size) > ns.getServerMoneyAvailable(HOME)) {
+						ns.print("Not enough money yet for new server.");
+						await ns.sleep(60000);
+					}
+					// buy the server (root.js will take care of hacking)
+					ns.purchaseServer(serv, size);
+				}
+			}
+			for (let i = 0; i < number; i++) {
+				// set the server name
+				let serv = "pserv-" + i;
+				// check if the server already exists, if it does, see if it is upgraded
+				if (ns.serverExists(serv)) {
+					let servram = ns.getServerMaxRam(serv);
+					// counting how many servers are fully upgraded
+					if (servram >= LIMIT) {
+						fullservs++;
+					} else {
+						fullservs = 0;
+						break;
+					}
+				}
+			}
+			await ns.sleep(100);
+		}
+		ns.print("All servers fully upgraded");
+	} else {
+		// start a for loop that goes through each server name
+		for (let i = 0; i < number; i++) {
+			// set the server name
+			let serv;
+			if (i < 10) {
+				serv = "pserv-0" + i;
+			} else {
+				serv = "pserv-" + i;
+			}
+			// check if the server already exists, if it does, skip it
+			for (let j = 0; j < 24 && ns.serverExists(serv); j++) {
+				if ((i + j) < 10) {
+					serv = "pserv-0" + (i + j);
+				} else {
+					serv = "pserv-" + (i + j);
+				}
+				if ((i + j) >= 24) {
+					ns.print("Maximum amount of purchased servers acquired.");
+					ns.exit();
+				}
+			}
+			// wait to buy the server until we have enough money
+			while (ns.getPurchasedServerCost(size) > ns.getServerMoneyAvailable(HOME)) {
+				ns.print("Not enough money yet for new server.");
+				await ns.sleep(60000);
+			}
+			// buy the server (root.js will take care of hacking)
+			ns.purchaseServer(serv, size);
+		}
+	}
+	
+	if (debug == true) {
+		ns.print("Debug time!");
+		await ns.sleep(60000);
+	}
+}
+
+
+//	enter ram size, number of servers, upgrade yes or no.
+//	auto copy and exec hack.js at maximum threads
+\ No newline at end of file
diff --git a/bitburnerFiles1026/servers.txt b/bitburnerFiles1026/servers.txt
new file mode 100644
index 0000000..9c25673
--- /dev/null
+++ b/bitburnerFiles1026/servers.txt
@@ -0,0 +1,97 @@
+home
+n00dles
+foodnstuff
+sigma-cosmetics
+joesguns
+hong-fang-tea
+harakiri-sushi
+iron-gym
+pserv-0
+pserv-1
+pserv-2
+pserv-3
+pserv-4
+pserv-5
+pserv-6
+pserv-7
+pserv-8
+pserv-9
+pserv-10
+pserv-11
+pserv-12
+pserv-13
+pserv-14
+pserv-15
+pserv-16
+pserv-17
+pserv-18
+pserv-19
+pserv-20
+pserv-21
+pserv-22
+pserv-23
+pserv-24
+darkweb
+CSEC
+nectar-net
+max-hardware
+zer0
+neo-net
+phantasy
+silver-helix
+omega-net
+netlink
+johnson-ortho
+crush-fitness
+the-hub
+computek
+avmnite-02h
+syscore
+catalyst
+zb-institute
+I.I.I.I
+summit-uni
+rothman-uni
+lexo-corp
+aevum-police
+rho-construction
+alpha-ent
+millenium-fitness
+global-pharm
+snap-fitness
+galactic-cyber
+aerocorp
+omnia
+deltaone
+unitalife
+defcomm
+solaris
+zeus-med
+icarus
+univ-energy
+infocomm
+taiyang-digital
+nova-med
+zb-def
+titan-labs
+run4theh111z
+applied-energetics
+microdyne
+fulcrumtech
+stormtech
+helios
+vitalife
+.
+omnitek
+kuai-gong
+4sigma
+b-and-a
+nwo
+blade
+clarkinc
+powerhouse-fitness
+ecorp
+megacorp
+fulcrumassets
+The-Cave
+w0r1d_d43m0n
diff --git a/bitburnerFiles1026/shell/java.js b/bitburnerFiles1026/shell/java.js
new file mode 100644
index 0000000..fe4c8f9
--- /dev/null
+++ b/bitburnerFiles1026/shell/java.js
@@ -0,0 +1,9 @@
+/** @param {NS} ns 
+ * @link {RunOptions} ro
+*/
+
+// run as 
+// 		java 'FUNCTION'
+export async function main(ns) {
+	ns.exec("shell/js.js", "home", {threads:1, ramOverride:32}, ns.args[0])
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/shell/js.js b/bitburnerFiles1026/shell/js.js
new file mode 100644
index 0000000..3755121
--- /dev/null
+++ b/bitburnerFiles1026/shell/js.js
@@ -0,0 +1,4 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	ns.tprint(await eval(ns.args[0]));
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/start.js b/bitburnerFiles1026/start.js
new file mode 100644
index 0000000..4061e25
--- /dev/null
+++ b/bitburnerFiles1026/start.js
@@ -0,0 +1,234 @@
+let ports;
+const HOME = "home";
+
+/** @param {NS} ns */
+export async function main(ns) {
+	let lvlpercent = 2 / 3;
+	let ram = ns.getServerMaxRam(HOME);
+
+	let debug = false;
+	if (ns.args[0] == "debugging") {
+		debug = true;
+	} else if (ns.args[0] == "--help") {
+		ns.tprint("\n This script should be run to start all automated programs.\n Such programs include:\n Hacking the best server available using every server available.\n Buying and upgrading max hacknet nodes.\n Purchasing the maximum amount of servers with 1/2 Ram of the home server.");
+		ns.exit();
+	}
+
+	ports = [
+		"NUKE.exe",
+		"BruteSSH.exe",
+		"FTPCrack.exe",
+		"RelaySMTP.exe",
+		"HTTPWorm.exe",
+		"SQLInject.exe"
+	];
+	// List of targets for each level of root function
+	const targets = [
+		"harakiri-sushi",
+		"iron-gym",
+		"the-hub",
+		"rho-construction",
+		"global-pharm",
+		"deltaone",
+	];
+
+	ns.tail();
+	ns.moveTail(1050, 425);
+	ns.resizeTail(250, 100);
+
+	// stop logging certain actions
+	ns.disableLog("ALL");
+	ns.clearLog();
+
+	// too expensive
+	// Only write to these files if its been less than a minute since last aug 
+	if (ns.getResetInfo().lastAugReset < 60000) {
+		ns.write("stockgains.txt", "", "w");
+		ns.write("augbaseprice.txt", ns.singularity.getAugmentationPrice("NeuroFlux Governor"), "w");
+	}
+
+	// Kill all instances of batch and batcher on startup
+	// to prevent errors from batch trying to use the object from batcher
+	ns.scriptKill("batch/batcher.js", HOME);
+	ns.scriptKill("batch/batch.js", HOME);
+
+	if (ns.getHackingLevel() < 40) {
+		ns.scriptKill("hack.js", HOME);
+		ns.print("Running root script #0, hacking ", "joesguns");
+		ns.nuke("joesguns");
+		ns.exec("hack.js", HOME, (ns.getServerMaxRam(HOME) > 200) ? (Math.max(Math.floor((ns.getServerMaxRam(HOME) - ns.getServerUsedRam(HOME) - 200) / 2.4), 10)) : (Math.max(Math.floor((ns.getServerMaxRam(HOME) - ns.getScriptRam("start.js")) / 2.4), 10)), "joesguns", true);
+	}
+
+	// too expensive
+	// start working for Sector-12 to get hacking exp
+	if (ns.getServerMoneyAvailable(HOME) >= 15000000) {
+		const invites = ns.singularity.checkFactionInvitations();
+		for (let i = 0; i < invites.length; i++) {
+			if (invites[i] == "Sector-12") {
+				ns.singularity.joinFaction(invites[i]);
+			}
+		}
+		ns.singularity.workForFaction("Sector-12", "hacking", false);
+	}
+
+	// start autoinfil
+	ns.exec("autoinfiltrate.js", HOME, 1, "--quiet");
+
+	// start backdooring faction servers to get invites
+	ns.print("Running milestones.js");
+	ns.scriptKill("milestones.js", HOME);
+	ns.exec("milestones.js", HOME);
+
+	// start augment monitor
+	ns.print("Running augments.js");
+	ns.scriptKill("augments.js", HOME);
+	ns.exec("augments.js", HOME);
+
+	// start home monitor
+	// upgrades ram and cores
+	// joins factions
+	ns.print("Running home.js");
+	ns.scriptKill("home.js", HOME);
+	ns.exec("home.js", HOME);
+
+	// too expensive
+	if (ns.getPlayer().money > 200000) {
+		ns.singularity.purchaseTor();
+	}
+
+	// Buy all of the .exe's
+	let m = 0;
+	for (let i = 0; i < ports.length; ++i) {
+		// too expensive
+		if (!ns.fileExists(ports[i])) {
+			// too expensive
+			if (ns.getServerMoneyAvailable(HOME) > ns.singularity.getDarkwebProgramCost(ports[i])) {
+				ns.singularity.purchaseProgram(ports[i]);
+			}
+			ns.print("Waiting for ", ports[i]);
+			while (!ns.fileExists(ports[i])) {
+				if (ns.getServerMoneyAvailable(HOME) > 250000000) {
+					buyall(ns);
+				}
+				await ns.sleep(10000);
+			}
+		}
+		// too expensive
+		if (ns.getServerRequiredHackingLevel(targets[i]) > (ns.getHackingLevel() * lvlpercent)) {
+			ns.print("Waiting to reach hacking level ", (ns.getServerRequiredHackingLevel(targets[i]) / lvlpercent), " to hack ", targets[i]);
+			while (ns.getServerRequiredHackingLevel(targets[i]) > (ns.getHackingLevel() * lvlpercent)) {
+				if (ns.getServerMoneyAvailable(HOME) > 5000000000) {
+					buyall(ns);
+				}
+				await ns.sleep(60000);
+			}
+		}
+
+		// Try to root all targets
+		if (!ns.hasRootAccess("deltaone") && ns.fileExists("SQLInject.exe") && !ns.isRunning("root.js")) {
+			ns.exec("root.js", HOME)
+		}
+		// Kill hack.js for foodnstuff
+		if (ns.getHackingLevel() > 200) {
+			ns.scriptKill("hack.js", HOME);
+		}
+		// Run hacker.js
+		if (!(ns.scriptRunning("hwgw/hacker.js", HOME))) {
+			ns.print("Running hwgw/hacker.js");
+			ns.exec("hwgw/hacker.js", HOME);
+		}		
+
+		// too expensive
+		if (ns.getServerMoneyAvailable(HOME) > 5000000000) {
+			buyall(ns);
+		}
+		
+
+		if (ports[i] == "NUKE.exe") {
+		} else if (ports[i] == "BruteSSH.exe") {
+			// ns.print("Running hacknet2.js");
+			// ns.scriptKill("hacknet2.js", HOME);
+			// ns.exec("hacknet2.js", HOME, 1, debug);
+		} else if (ports[i] == "FTPCrack.exe") {
+			ns.print("Running the server purchasing script");
+			ns.scriptKill("servers.js", HOME);
+			ns.exec("servers.js", HOME, 1, 512, "max", false, debug);
+		} else if (ports[i] == "RelaySMTP.exe" && ns.stock.has4SDataTIXAPI()) {
+			ns.print("Running the stocker script");
+			ns.scriptKill("stocks.js", HOME);
+			ns.exec("stocks.js", HOME, 1);
+		}
+	}
+
+	await ns.sleep(1000);
+
+	ns.print("Going idle now");
+	
+	// while loop to check every minute if something should be done
+	// (checks if home has more RAM than before)
+	while (true) {
+		// too expensive
+		if (ram != ns.getServerMaxRam(HOME)) {
+			if (ns.getServerMoneyAvailable(HOME) >= ns.singularity.getUpgradeHomeRamCost()) {
+				ns.singularity.upgradeHomeRam();
+			}
+		}
+		// Run batcher on top 4 targets
+		if (!ns.getRunningScript("batch/batcher.js", HOME, "deltaone") && ns.getHackingLevel() > ns.getServerRequiredHackingLevel("deltaone")) {
+			ns.print("Running batch/batcher.js");
+			ns.exec("batch/batcher.js", HOME, 1, "deltaone");
+		}
+		if (!ns.getRunningScript("batch/batcher.js", HOME, "zeus-med") && ns.getHackingLevel() > ns.getServerRequiredHackingLevel("deltaone")) {
+			ns.print("Running batch/batcher.js");
+			ns.exec("batch/batcher.js", HOME, 1, "zeus-med");
+		}
+		if (!ns.getRunningScript("batch/batcher.js", HOME, "aerocorp") && ns.getHackingLevel() > ns.getServerRequiredHackingLevel("deltaone")) {
+			ns.print("Running batch/batcher.js");
+			ns.exec("batch/batcher.js", HOME, 1, "aerocorp");
+		}
+		if (!ns.getRunningScript("batch/batcher.js", HOME, "zb-institute") && ns.getHackingLevel() > ns.getServerRequiredHackingLevel("deltaone")) {
+			ns.print("Running batch/batcher.js");
+			ns.exec("batch/batcher.js", HOME, 1, "zb-institute");
+		}
+		if (!ns.fileExists("Formulas.exe") && ns.getServerMoneyAvailable(HOME) > 5000000000) {
+			// too expensive
+			buyall(ns);
+			ns.print("Running the server upgrading script");
+			ns.scriptKill("servers.js", HOME);
+			ns.exec("servers.js", HOME, 1, 2048, "max", true, debug);
+		}
+		if (ns.serverExists("pserv-00")) {
+			if (ns.getPurchasedServerUpgradeCost("pserv-00", ns.getServerMaxRam("pserv-00") * 2) < 1000000000) {
+				if (ns.isRunning("servers.js", HOME, 1, 512, "max", false, debug) || !ns.isRunning("servers.js", HOME, 1, 2048, "max", true, debug)) {
+					ns.scriptKill("servers.js", HOME);
+					ns.exec("servers.js", HOME, 1, 2048, "max", true, debug);
+				}
+			}
+		}
+		if (m < 4) {
+			// start backdooring faction servers to get invites
+			ns.print("Running milestones.js");
+			ns.scriptKill("milestones.js", HOME);
+			ns.exec("milestones.js", HOME);
+			m++;
+		}
+		await ns.sleep(60000);
+	}
+}
+
+function buyall(ns) {
+	// too expensive
+	for (let i = 1; i < ports.length; ++i) {
+		if (!ns.fileExists(ports[i])) {
+			ns.singularity.purchaseProgram(ports[i]);
+		}
+	}
+	if (ns.getServerMoneyAvailable(HOME) > 5000000000) {
+		ns.singularity.purchaseProgram("Formulas.exe");
+	}
+}
+
+/*
+	Start.js should continuously check if new .exe files have been made, then re-run root.js when they have been made,
+	so that better servers are targeted, servers that will make more money.
+*/
+\ No newline at end of file
diff --git a/bitburnerFiles1026/stocker.js b/bitburnerFiles1026/stocker.js
new file mode 100644
index 0000000..708e654
--- /dev/null
+++ b/bitburnerFiles1026/stocker.js
@@ -0,0 +1,144 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	const sym = ns.args[0];
+	const target = ns.args[1];
+	let manip = ns.args[2];
+	let debug = ns.args[3];
+	let pricebought;
+	let pricesold;
+	debug = true;
+	
+	const maxmoney = 0;
+	if (sym === undefined) {
+		ns.print("arg 0 is the stock symbol");
+		ns.exit();
+	} else if (sym == "--help" || sym == "help" || sym == "-h") {
+		ns.tprint("\n script that buys stocks and sells high.\n 1st arg is the stock symbol.\n 2nd arg is the stock's server.\n 3rd arg is whether to hack and grow servers to manipulate stock prices.");
+		ns.exit();
+	}
+	if (target === undefined) {
+		ns.print("arg 1 is the target server");
+	} else {
+		maxmoney = ns.getServerMaxMoney(target);
+	}
+	if (manip === undefined) {
+		ns.print("arg 2 is boolean, proceeding with false");
+		manip = false;
+	}
+	if (debug === undefined) {
+		ns.print("arg 3 is debug; turning off");
+		debug = false;
+	}
+	let minprice = Number(ns.read("minprice.txt"));
+	let maxprice = Number(ns.read("maxprice.txt"));
+	const buyprice = minprice;
+	const sellprice = maxprice;
+	let shares = ns.stock.getMaxShares(sym);
+	//const minprice = ns.stock.
+	ns.disableLog("sleep");
+
+	if (manip == true) {
+		while (true) {
+			// Hack foodnstuff to bring price down
+			if (ns.getServerMoneyAvailable(target) != 0) {
+				ns.print("bringing price down.");
+				while (ns.getServerMoneyAvailable(target) != 0) {
+					ns.exec("run.js", "home", 1, target, "temphack.js");
+					await ns.sleep(5000);
+				}
+			}
+			// after price is down, buy max stock
+			// homemade place order command
+			if (ns.stock.getAskPrice(sym) > buyprice) {
+				ns.print("Waiting for price to drop");
+				while (ns.stock.getAskPrice(sym) > buyprice) {
+					ns.print(Floor(ns.stock.getAskPrice(sym)));
+					await ns.sleep(60000);
+					if (ns.stock.getAskPrice(sym) < minprice) {
+						minprice = ns.stock.getAskPrice(sym);
+						ns.write("minprice.txt", minprice, "w");
+					} else if (ns.stock.getBidPrice(sym) > maxprice) {
+						maxprice = ns.stock.getBidPrice(sym);
+						ns.write("maxprice.txt", maxprice, "w");
+					}
+				}
+			}
+			ns.stock.buyStock(sym, shares);
+			// after bought, raise price with grow
+			if (ns.getServerMoneyAvailable(target) < maxmoney) {
+				ns.print("bringing price up.");
+				while (ns.getServerMoneyAvailable(target) < maxmoney) {
+					ns.exec("run.js", "home", 1, target, "tempgrow.js");
+					await ns.sleep(5000);
+				}
+			}
+			// after raising price, sell all stock
+			if (ns.stock.getBidPrice(sym) < sellprice) {
+				ns.print("Waiting for price to increase");
+				while (ns.stock.getBidPrice(sym) < sellprice) {
+					ns.print(Floor(ns.stock.getBidPrice(sym)));
+					await ns.sleep(60000);
+					if (ns.stock.getBidPrice(sym) > maxprice) {
+						maxprice = ns.stock.getBidPrice(sym);
+						ns.write("maxprice.txt", maxprice, "w");
+					} else if (ns.stock.getAskPrice(sym) < minprice) {
+						minprice = ns.stock.getAskPrice(sym);
+						ns.write("minprice.txt", minprice, "w");
+					}
+				}
+			}
+			ns.stock.sellStock(sym, shares);
+			//repeat after 10 seconds
+			await ns.sleep(10000);
+		}
+	} else {
+		let bought = 0;
+		if (bought == 0) {
+
+			if (debug) {log(ns, sym);}
+			while (bought == 0) {
+				// if price is going up
+				if (debug) {ns.print("Forecast for ", sym, ": ", (ns.stock.getForecast(sym)).toFixed(2));}
+				if (ns.stock.getForecast(sym) > 0.5) {
+					ns.stock.buyStock(sym, shares);
+					pricebought = ns.stock.getAskPrice(sym) * shares;
+					bought++;
+					break;
+				}
+				await ns.sleep(6000);
+			}
+		} if (bought == 1) {
+			if (debug) {ns.print("Waiting for forecast to show going down.");}
+			while (bought == 1) {
+				// log window messages
+				if (debug) {log(ns, sym);}
+				if (ns.stock.getForecast(sym) < 0.5) {
+					ns.stock.sellStock(sym, shares);
+					pricesold = ns.stock.getBidPrice(sym) * shares;
+					bought--;
+					await ns.sleep(1000);
+					ns.exit();
+				}
+				await ns.sleep(6000);
+			}
+		}
+		gains(ns, pricebought, pricesold);
+	}
+}
+
+function log(ns, sym) {
+	ns.print("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
+	ns.print("Forecast for ", sym, ": ", (ns.stock.getForecast(sym)).toFixed(2));
+	ns.print("Price of ", sym, ": ", ns.stock.getPrice(sym));
+}
+
+function gains(ns, pricebought, pricesold) {
+	let net = pricesold - pricebought;
+	let prev = ns.read("stockgains.js");
+	let total = prev + net;
+	ns.write("stockgains.js", total, "w");
+}
+// round forecast to 1 decimal
+// shorten forecast message to *sym*: *number*
+// remove previous messages by adding a bunch of \n
+// add a price change message
+\ No newline at end of file
diff --git a/bitburnerFiles1026/stockgains.txt b/bitburnerFiles1026/stockgains.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/bitburnerFiles1026/stockgains.txt
diff --git a/bitburnerFiles1026/stocks.js b/bitburnerFiles1026/stocks.js
new file mode 100644
index 0000000..c456534
--- /dev/null
+++ b/bitburnerFiles1026/stocks.js
@@ -0,0 +1,25 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	let manip = ns.args[0];
+	if (manip == "-h" || manip == "help" || manip == "--help") {
+		ns.tprint("arg 0 is the boolean, to manipulate prices or not. \n True uses more scripts");
+		manip = false;
+	}
+	//ns.disableLog("sleep");
+	const syms = ns.stock.getSymbols();
+	while (true) {
+		for (let i = 0; i < syms.length; i++) {
+			let sym = syms[i];
+			if (ns.stock.getForecast(sym) > 0.5 && !(ns.getRunningScript("stocker.js", "home", sym))) {
+				if ((ns.stock.getAskPrice(sym) * ns.stock.getMaxShares(sym)) < ns.getServerMoneyAvailable("home")) {
+					ns.exec("stocker.js", "home", 1, sym);
+				}
+			}
+			await ns.sleep(1000);
+		}
+		await ns.sleep(1000);
+	}
+}
+
+// look through all the stocks to see what is going up, and run stocker on whatever is
+// 
+\ No newline at end of file
diff --git a/bitburnerFiles1026/target.js b/bitburnerFiles1026/target.js
new file mode 100644
index 0000000..c2872a2
--- /dev/null
+++ b/bitburnerFiles1026/target.js
@@ -0,0 +1,178 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	let target = "home";
+    let thread = 1;
+    const scriptRam = 2.4;
+
+    // Array of all purchased servers
+    //  Varying RAM sizes
+    const pservers = [
+        "pserv-0",
+        "pserv-1",
+        "pserv-2",
+        "pserv-3",
+        "pserv-4",
+        "pserv-5",
+        "pserv-6",
+        "pserv-7",
+        "pserv-8",
+        "pserv-9",
+        "pserv-10",
+        "pserv-11",
+        "pserv-12",
+        "pserv-13",
+        "pserv-14",
+        "pserv-15",
+        "pserv-16",
+        "pserv-17",
+        "pserv-18",
+        "pserv-19",
+        "pserv-20",
+        "pserv-21",
+        "pserv-22",
+        "pserv-23",
+    ];
+
+
+    // Array of all servers that don't need any ports opened
+    // to gain root access. These have  GB of RAM
+    const servers0Port = [
+        "n00dles",
+        "foodnstuff",
+        "sigma-cosmetics",
+        "joesguns",
+        "nectar-net",
+        "hong-fang-tea",
+        "harakiri-sushi"
+    ];
+
+
+    // Array of all servers that only need 1 port opened
+    // to gain root access. These have 32 GB of RAM
+    const servers1Port = [
+        "neo-net",
+        "zer0",
+        "max-hardware",
+        "iron-gym"
+    ];
+
+
+    // 2 port servers
+    const servers2Port = [
+        "omega-net",
+        "silver-helix",
+        "phantasy",
+        "johnson-ortho",
+        "crush-fitness",
+        "the-hub",
+        "avmnite-02h"
+    ];
+
+    // 3 port servers
+    const servers3Port = [
+        "netlink",
+        "computek",
+        "I.I.I.I",
+        "summit-uni",
+        "catalyst",
+        "rothman-uni",
+        "millenium-fitness",
+        "rho-construction"
+    ];
+
+    // 4 port serves
+    const servers4Port = [
+        "aevum-police",
+        "global-pharm",
+        "syscore",
+        "lexo-corp",
+        "unitalife",
+        "snap-fitness",
+        "alpha-ent",
+        "univ-energy",
+        "nova-med",
+        "zb-def"
+    ];
+
+    // 5 port servers
+    const servers5Port = [
+        "zb-institute",
+        "galactic-cyber",
+        "aerocorp",
+        "omnia",
+        "deltaone",
+        "taiyang-digital",
+        "icarus",
+        "zeus-med",
+        "infocomm",
+        "solaris",
+        "defcomm"
+    ];
+
+    //decide the target
+
+	for (let i = 0; i < servers0Port.length; ++i) {
+		const serv = servers0Port[i];
+        if (ns.getServerMaxMoney(serv) > ns.getServerMaxMoney(target)) {
+            target = serv;
+        }
+	}
+	ns.print("Weak target acquired");
+	ns.write("targets.txt", "Weak target: " + target, "w");
+
+
+	for (let i = 0; i < servers1Port.length; ++i) {
+		const serv = servers1Port[i];
+        if (ns.getServerMaxMoney(serv) > ns.getServerMaxMoney(target)) {
+            target = serv;
+        }
+	}
+	ns.print("SSH target acquired");
+	ns.write("targets.txt", "\nSSH target: " + target, "a");
+
+
+	for (let i = 0; i < servers2Port.length; ++i) {
+		const serv = servers2Port[i];
+        if (ns.getServerMaxMoney(serv) > ns.getServerMaxMoney(target)) {
+            target = serv;
+        }
+	}
+	ns.print("FTP target acquired");
+	ns.write("targets.txt", "\nFTP target: " + target, "a");
+
+
+	for (let i = 0; i < servers3Port.length; ++i) {
+		const serv = servers3Port[i];
+        if (ns.getServerMaxMoney(serv) > ns.getServerMaxMoney(target)) {
+            target = serv;
+        }
+	}
+	ns.print("SMTP target acquired");
+	ns.write("targets.txt", "\nSMTP target: " + target, "a");
+
+
+	for (let i = 0; i < servers4Port.length; ++i) {
+		const serv = servers4Port[i];
+
+        if (ns.getServerMaxMoney(serv) > ns.getServerMaxMoney(target)) {
+            target = serv;
+        }
+	}
+	ns.print("HTTP target acquired");
+	ns.write("targets.txt", "\nHTTP target: " + target, "a");
+
+
+    for (let i = 0; i < servers5Port.length; ++i) {
+		const serv = servers5Port[i];
+
+        if (ns.getServerMaxMoney(serv) > ns.getServerMaxMoney(target)) {
+            target = serv;
+        }
+	}
+	ns.print("SQL target acquired");
+	ns.write("targets.txt", "\nSQL target: " + target, "a");
+
+
+	ns.tprint("targets found. Ending process.");
+	ns.exit();
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/targets.js b/bitburnerFiles1026/targets.js
new file mode 100644
index 0000000..9dc9c02
--- /dev/null
+++ b/bitburnerFiles1026/targets.js
@@ -0,0 +1,45 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	ns.clear("moneyServers.txt");
+	const servers = netscan(ns);
+	for (let i = 0; i < servers.length; i++) {
+		if (ns.getServer(servers[i]).moneyMax > 0) {
+			ns.write("moneyServers.txt", servers[i], "a");
+			ns.write("moneyServers.txt", "\n", "a");
+		}
+	}
+	
+}
+
+/** @param {NS} ns */
+function netscan(ns) {
+	//Initialize the set and seed it with the a host so that the next line
+	//has something to work with.
+	let hosts = new Set(["home"]);
+
+	//Sets have the useful property that when elements are added to them in
+	//their own forEach loop, they will iterate over those new elements as
+	//well. Be careful about this with other data structures and languages!
+	//It is somewhat uncommon for data structures to tolerate manipulation
+	//during iteration.
+	//Anyway, because of this, we can add new neighbors to the set as we
+	//find them, and they will be scanned as well.
+	//We also don't have to check if the set already contains the host,
+	//because sets are sets of unique elements. The underlying structure of
+	//a set typically makes it impossible to add duplicate elements at all.
+	hosts.forEach(h => { ns.scan(h).forEach(n => hosts.add(n)); });
+
+	//Sets are irritating to work with in list contexts, because concepts
+	//like sorting are inapplicable to them (e.g. you might want to sort
+	//these servers by difficulty). So we convert it back to a list.
+	//If you look at the printed output, you might notice that the order
+	//appears to be similar to the order in which the servers were scanned.
+	//Do not rely on this behavior! It is purely a side effect of the
+	//implementation of the set. A set has no concept of "order" and a
+	//change in its implementation (or a new compiler optimization) could
+	//produce a different order.
+	//Of course, you might ask how it is the above "forEach" loop works if
+	//the set has no order. The answer is... uh oh, something is wrong with
+	//the b1^n&de... do you feel it? Run... save yourself...
+	return Array.from(hosts);
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/targets.txt b/bitburnerFiles1026/targets.txt
new file mode 100644
index 0000000..2898eb9
--- /dev/null
+++ b/bitburnerFiles1026/targets.txt
@@ -0,0 +1,6 @@
+Weak target: harakiri-sushi
+SSH target: iron-gym
+FTP target: the-hub
+SMTP target: rho-construction
+HTTP target: global-pharm
+SQL target: deltaone
+\ No newline at end of file
diff --git a/bitburnerFiles1026/tempgrow.js b/bitburnerFiles1026/tempgrow.js
new file mode 100644
index 0000000..3591803
--- /dev/null
+++ b/bitburnerFiles1026/tempgrow.js
@@ -0,0 +1,34 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	// What server will be targeted?
+	let target = ns.args[0];
+	if (target === undefined) {
+		ns.exit();
+	}
+	const securityThresh = ns.getServerMinSecurityLevel(target) + 5;
+	ns.getServerSecurityLevel(target);
+	ns.getServerMaxMoney(target);
+	ns.getServerMoneyAvailable(target);
+
+	while (ns.getServerSecurityLevel(target) > (securityThresh)) {
+		// If the server's security level is above our threshold, weaken it
+		await ns.weaken(target);
+	}
+	while (ns.getServerMoneyAvailable(target) < ns.getServerMaxMoney(target)) {
+		// If the server's security level is above our threshold, weaken it
+		if (ns.getServerSecurityLevel(target) > (securityThresh)) {
+			await ns.weaken(target);
+		} else {
+			await ns.grow(target);
+		}
+	}
+	while (ns.getServerSecurityLevel(target) > (securityThresh)) {
+		// If the server's security level is above our threshold, weaken it
+		await ns.weaken(target);
+	}
+	await ns.sleep(500);
+	ns.getServerMinSecurityLevel(target);
+	ns.getServerSecurityLevel(target);
+	ns.getServerMaxMoney(target);
+	ns.getServerMoneyAvailable(target);
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/temphack.js b/bitburnerFiles1026/temphack.js
new file mode 100644
index 0000000..949289c
--- /dev/null
+++ b/bitburnerFiles1026/temphack.js
@@ -0,0 +1,22 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	// What server will be targeted?
+	let target = ns.args[0];
+	if (target === undefined) {
+		ns.exit();
+	}
+	
+	ns.print("At min security: ", ns.getServerMinSecurityLevel(target) == ns.getServerSecurityLevel(target));
+	ns.print("At max money: ", ns.getServerMaxMoney(target) == ns.getServerMoneyAvailable(target));
+	
+	// while (ns.getServerSecurityLevel(target) > (securityThresh)) {
+	// 	// If the server's security level is above our threshold, weaken it
+	// 	await ns.weaken(target);
+	// }
+	await ns.hack(target);
+	// await ns.weaken(target);
+	// await ns.sleep(1000);
+	
+	ns.getServerMaxMoney(target);
+	ns.getServerMoneyAvailable(target);
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/test.js b/bitburnerFiles1026/test.js
new file mode 100644
index 0000000..c9483b6
--- /dev/null
+++ b/bitburnerFiles1026/test.js
@@ -0,0 +1,4 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	ns.singularity.upgradeHomeRam();
+}
+\ No newline at end of file
diff --git a/bitburnerFiles1026/threads.js b/bitburnerFiles1026/threads.js
new file mode 100644
index 0000000..51729fe
--- /dev/null
+++ b/bitburnerFiles1026/threads.js
@@ -0,0 +1,13 @@
+/** @param {NS} ns */
+export async function main(ns) {
+	//const call = ns.args[0];
+	const call = "hack";
+	const server = ns.args[0];
+	// if (ns.args[0] === undefined || ns.args[1] === undefined || ns.args[0] == "help") {
+	// 	ns.tprint("1st arg is the call type; ie. hack, weaken, or grow\n2nd arg is the server name");
+	// }
+
+	if (call == "hack") {
+		ns.tprint(ns.hackAnalyzeThreads(server, ns.getServerMoneyAvailable(server)));
+	}
+}
+\ No newline at end of file
author	AlmightyMiau <almightymeow612@gmail.com>	2024-10-26 13:06:14 -0700
committer	AlmightyMiau <almightymeow612@gmail.com>	2024-10-26 13:06:14 -0700
commit	1ca00b3b73a9699e41f81e154cea32934c16de03 (patch)
tree	d8ff8fe937b06cf40458aac232953b19665bcc6e