function getScaling12Boosters() {
	let x = new Decimal(1)
	if (player.ps.upgrades.includes(22)) x = x.times(LAYER_UPGS.ps[22].currently())
	return x
}

function addToBoosterBase() {
	let toAdd = new Decimal(0)
	if (player.b.upgrades.includes(12)) toAdd = toAdd.add(LAYER_UPGS.b[12].currently())
	if (player.b.upgrades.includes(13)) toAdd = toAdd.add(LAYER_UPGS.b[13].currently())
	if (player.t.upgrades.includes(11)&&!(tmp.challActive?tmp.challActive.h[12]:true)) toAdd = toAdd.add(LAYER_UPGS.t[11].currently())
	if (player.t.upgrades.includes(31)&&!(tmp.challActive?tmp.challActive.h[12]:true)) toAdd = toAdd.add(25)
	if (player.t.upgrades.includes(33)&&!(tmp.challActive?tmp.challActive.h[12]:true)) toAdd = toAdd.add(40)
	if (player.e.unl) toAdd = toAdd.add(tmp.enhEff2)
	if (player.e.upgrades.includes(11)&&!(tmp.challActive?tmp.challActive.h[12]:true)) toAdd = toAdd.add(LAYER_UPGS.e[11].currently().b)
	if (player.s.unl && tmp.s !== undefined) toAdd = toAdd.add(tmp.s.sbEff[2])
	if (player.sb.upgrades.includes(21)) toAdd = toAdd.add(LAYER_UPGS.sb[21].currently())
	
	if (player.b.upgrades.includes(31)) toAdd = toAdd.times(LAYER_UPGS.b[31].currently())
	if (player.q.upgrades.includes(53)) toAdd = toAdd.times(tmp.enhEff2)
	if (player.sb.unl) toAdd = toAdd.times(tmp.layerEffs.sb)
	return toAdd
}

function getFreeBoosters() {
	let free = new Decimal(0)
	if (player.t.upgrades.includes(24)&&!(tmp.challActive?tmp.challActive.h[12]:true)) free = free.add(18)
	if (player.b.upgrades.includes(32)) free = free.add(LAYER_UPGS.b[32].currently())
	if (player.b.upgrades.includes(33)) free = free.add(100)
	return free
}

function getBoosterPower() {
	let power = new Decimal(1)
	if (spellActive(1)) power = power.times(tmp.spellEffs[1])
	if (player.sp.upgrades.includes(34)) power = power.times(1.25)
	return power
}

function addToGenBase() {
	let toAdd = new Decimal(0)
	if (player.g.upgrades.includes(12)) toAdd = toAdd.add(LAYER_UPGS.g[12].currently())
	if (player.g.upgrades.includes(13)) toAdd = toAdd.add(LAYER_UPGS.g[13].currently())
	if (player.g.upgrades.includes(33)) toAdd = toAdd.add(LAYER_UPGS.g[33].currently())
	if (player.e.unl) toAdd = toAdd.add(tmp.enhEff2)
	if (player.e.upgrades.includes(11)&&!(tmp.challActive?tmp.challActive.h[12]:true)) toAdd = toAdd.add(LAYER_UPGS.e[11].currently().g)
	if (player.s.unl && tmp.s !== undefined) toAdd = toAdd.add(tmp.s.sbEff[2])
		
	if (player.h.challs.includes(51)) toAdd = toAdd.times(LAYER_CHALLS.h[51].currently())
	if (player.q.upgrades.includes(53)) toAdd = toAdd.times(tmp.enhEff2)
	return toAdd
}

function getGenPow() {
	let pow = new Decimal(1)
	if (player.g.upgrades.includes(34)) pow = pow.times(LAYER_UPGS.g[34].currently())
	if (player.sp.upgrades.includes(34)) pow = pow.times(1.25)
	return pow
}

function getGenPowerGainMult() {
	let mult = new Decimal(1)
	if (player.g.upgrades.includes(21)) mult = mult.times(LAYER_UPGS.g[21].currently())
	if (player.g.upgrades.includes(25)) mult = mult.times(LAYER_UPGS.g[25].currently())
	if (player.e.upgrades.includes(35)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.e[35].currently())
	if (player.s.upgrades.includes(12)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.s[12].currently())
	if (player.s.upgrades.includes(13)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.s[13].currently())
	if (player.q.unl && tmp.quirkEff) mult = mult.times(tmp.quirkEff)
	if (player.g.upgrades.includes(35)) mult = mult.times(LAYER_UPGS.g[35].currently())
	return mult
}

function getGenPowerEffExp() {
	let exp = new Decimal(1/3)
	if (player.s.upgrades.includes(34)&&!(tmp.challActive?tmp.challActive.h[12]:true)) exp = exp.add(LAYER_UPGS.s[34].currently())
	if (player.b.upgrades.includes(21)) exp = exp.times(2)
	if (player.b.upgrades.includes(22)) exp = exp.times(1.2)
	if (player.e.upgrades.includes(21)&&!(tmp.challActive?tmp.challActive.h[12]:true)) exp = exp.times(1.15)
	if (player.h.challs.includes(11)) exp = exp.times(1.25)
	if (player.h.challs.includes(42)) exp = exp.times(3)
	return exp;
}

function getGenPowerEff() {
	if (tmp.challActive ? tmp.challActive.h[11] : true) return new Decimal(1)
	let eff = player.g.power.add(1).pow(getGenPowerEffExp());
	return eff
}


function getEnhancerPow() {
	if (tmp.challActive ? tmp.challActive.h[22] : true) return new Decimal(0);
	if (tmp.challActive ? tmp.challActive.h[41] : true) return new Decimal(0);
	let pow = new Decimal(1)
	if (player.e.upgrades.includes(25)&&!(tmp.challActive?tmp.challActive.h[12]:true)) pow = pow.times(LAYER_UPGS.e[25].currently())
	if (player.e.upgrades.includes(31)&&!(tmp.challActive?tmp.challActive.h[12]:true)) pow = pow.times(LAYER_UPGS.e[31].currently())
	if (player.h.challs.includes(31)) pow = pow.times(2)
	if (player.q.upgrades.includes(42)) pow = pow.times(1.4)
	if (player.ba.upgrades.includes(32)) pow = pow.times(LAYER_UPGS.ba[32].currently())
	return pow
}

function getEnhancerEff() {
	if (!player.e.unl) return new Decimal(1)
	let e = player.e.enhancers.sub(tmp.subbedEnh).times(tmp.enhPow)
	let eff;
	if (e.gte(0)) eff = Decimal.pow(25, e.pow(1.1))
	else eff = Decimal.pow(1/25, e.times(-1).pow(1.1))
	return eff
}

function getEnhancerEff2() {
	if (!player.e.unl) return new Decimal(0)
	let e = player.e.enhancers.sub(tmp.subbedEnh).times(tmp.enhPow)
	let eff;
	if (e.gte(0)) eff = e.pow(0.8)
	else eff = e.times(-1).pow(0.8).times(-1)
	return eff;
}

function getEnhancerCost() {
	let e = player.e.enhancers
	if (e.gte(25)) e = e.pow(2).div(25)
	let cost = Decimal.pow(2, e.pow(1.5))
	return cost.floor()
}

function buyEnhancer() {
	let cost = getEnhancerCost()
	if (player.e.points.lt(cost)) return
	player.e.points = player.e.points.sub(cost)
	player.e.enhancers = player.e.enhancers.add(1)
}

function maxEnhancers() {
	let target = player.e.points.max(1).log(2).root(1.5)
	if (target.gte(25)) target = target.times(25).sqrt()
	target = target.add(1).floor()
	if (target.lte(player.e.enhancers)) return
	player.e.enhancers = player.e.enhancers.max(target)
}

function getFreeExtCapsules() {
	let amt = new Decimal(0)
	if (player.t.upgrades.includes(12)&&!(tmp.challActive?tmp.challActive.h[12]:true)) amt = amt.add(1)
	if (player.h.unl) amt = amt.add(tmp.layerEffs.h)
	return amt
}

function getCapPow() {
	if (tmp.challActive ? tmp.challActive.h[41] : true) return new Decimal(0)
	let pow = new Decimal(1)
	if (player.q.upgrades.includes(33)) pow = pow.times(LAYER_UPGS.q[33].currently())
	if (spellActive(2)) pow = pow.times(tmp.spellEffs[2])
	return pow
}

function getFreeExtPow() {
	if (tmp.challActive ? tmp.challActive.h[22] : true) return new Decimal(0)
	let pow = new Decimal(1)
	return pow
}

function getTimeEnergyEff() {
	if (!player.t.unl) return new Decimal(1)
	let exp = 1.2
	if (player.t.upgrades.includes(21)&&!(tmp.challActive?tmp.challActive.h[12]:true)) exp = 1.75
	let eff = player.t.energy.add(1).pow(exp)
	return eff;
}

function getTimeEnergyGainMult() {
	if (!player.t.unl) return new Decimal(1)
	let mult = new Decimal(1);
	if (player.t.upgrades.includes(21)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[21].currently())
	if (player.t.upgrades.includes(22)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[22].currently())
	if (player.t.upgrades.includes(23)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[23].currently())
	if (player.t.upgrades.includes(34)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[34].currently())
	return mult;
}

function getTimeEnergyLimitMult() {
	if (!player.t.unl) return new Decimal(1)
	let mult = new Decimal(1);
	if (player.t.upgrades.includes(12)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[12].currently())
	if (player.t.upgrades.includes(21)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[21].currently())
	if (player.t.upgrades.includes(22)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[22].currently())
	if (player.t.upgrades.includes(23)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[23].currently())
	if (player.t.upgrades.includes(34)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mult = mult.times(LAYER_UPGS.t[34].currently())
	if (player.q.upgrades.includes(23)) mult = mult.times(1e10)
	if (player.q.upgrades.includes(24)) mult = mult.times(LAYER_UPGS.q[24].currently())
	if (player.m.upgrades.includes(23)) mult = mult.times("1e500")
	return mult;
}

function getExtCapsuleCost() {
	let amt = player.t.extCapsules
	if (amt.gte(25) && !player.ba.upgrades.includes(43)) amt = amt.pow(2).div(25)
	let cost = amt.times(0.4).pow(1.2).add(1).times(10)
	return cost.floor()
}

function buyExtCapsule() {
	if (!player.t.unl) return
	let cost = getExtCapsuleCost()
	if (player.b.points.lt(cost)) return
	player.b.points = player.b.points.sub(cost)
	player.t.extCapsules = player.t.extCapsules.add(1)
}

function maxExtTimeCapsules() {
	let target = player.b.points.add(1).div(10).sub(1).root(1.2).div(0.4)
	if (target.gte(25)&&!player.ba.upgrades.includes(43)) target = target.times(25).sqrt()
	target = target.add(1).floor().max(0)
	player.t.extCapsules = player.t.extCapsules.max(target)
}

function addToTimeBase() {
	let toAdd = new Decimal(0)
	if (player.m.upgrades.includes(44)) toAdd = toAdd.add(LAYER_UPGS.m[44].currently())
	return toAdd
}

function multiplyToTimeBase() {
	let x = new Decimal(1)
	if (player.l.unl && tmp.l !== undefined) x = x.times(tmp.l.lbEff[3])
	return x
}

function getSpace() {
	let baseSpace = player.s.best.pow(1.1).times(3).floor()
	if (player.s.upgrades.includes(13)&&!(tmp.challActive?tmp.challActive.h[12]:true)) baseSpace = baseSpace.add(2);
	if (player.s.upgrades.includes(24)&&!(tmp.challActive?tmp.challActive.h[12]:true)) baseSpace = baseSpace.add(3);
	if (player.ss.unl) baseSpace = baseSpace.add(tmp.ssEff1)
	if (player.ss.upgrades.includes(11)) baseSpace = baseSpace.add(LAYER_UPGS.ss[11].currently())
	return baseSpace.sub(player.s.spent).max(0)
}

let SPACE_BUILDINGS = {
	max: 10,
	1: {
		cost: new Decimal(1e3),
		eff(x) {
			let ret = Decimal.pow(Decimal.add(1, x.pow((player.s.upgrades.includes(31)&&!(tmp.challActive?tmp.challActive.h[12]:true))?2.75:1)), player.s.points.sqrt()).times(Decimal.mul(4, x.pow((player.s.upgrades.includes(31)&&!(tmp.challActive?tmp.challActive.h[12]:true))?2.75:1))).max(1)
			if (player.ba.upgrades.includes(42)) ret = ret.pow(LAYER_UPGS.ba[42].currently())
			return ret
		},
		effDesc(x) {
			return "Space Energy boosts Point gain & Prestige Point gain ("+format(x)+"x)"
		}
	},
	2: {
		cost: new Decimal(1e10),
		eff(x) {
			if (player.s.upgrades.includes(43)) {
				x = Decimal.pow(1.0001, x).times(x.sqrt())
				if (x.gte("e600")) x = Decimal.pow(10, x.log10().times(600).sqrt())
				return x
			} else return x.sqrt()
		},
		effDesc(x) {
			return "Adds to base of Booster/Generator effects by "+format(x)
		}
	},
	3: {
		cost: new Decimal(1e25),
		eff(x) {
			x = Decimal.pow(1e18, x.pow(0.9))
			if (x.gte("e3e9")) x = Decimal.pow(10, x.log10().times(9e18).cbrt())
			return x
		},
		effDesc(x) {
			return "Makes Boosters/Generators cheaper by "+format(x)+"x"
		}
	},
	4: {
		cost: new Decimal(1e48),
		eff(x) {
			let ret = x.add(1).pow(1.25)
			if (ret.gte(1e6)) ret = ret.log10().times(1e6/6)
			return ret;
		},
		effDesc(x) {
			return "Booster Upgrade 6's effect is raised to the power of "+format(x)
		}
	},
	5: {
		cost: new Decimal(1e100),
		eff(x) {
			return x.sqrt().times(2)
		},
		effDesc(x) {
			return "Add "+format(x)+" free levels to all previous Space Buildings"
		}
	},
	6: {
		cost: new Decimal("e6000000"),
		eff(x) {
			return x.div(1e3).add(1).sqrt()
		},
		effDesc(x) {
			return "You produce Life Power " + format(x) + "x faster"
		}
	},
	7: {
		cost: new Decimal("e6500000"),
		eff(x) {
			return Decimal.pow(1.05, x)
		},
		effDesc(x) {
			return "Reduce the requirement of Phantom Souls by " + format(x) + "x"
		}
	},
	8: {
		cost: new Decimal("e7000000"),
		eff(x) {
			return x.sqrt().div(100)
		},
		effDesc(x) {
			return "Gain " + format(x) + " free extra Quirk layers"
		}
	},
	9: {
		cost: new Decimal("e8000000"),
		eff(x) {
			return x.max(1).log10().div(3).max(1).cbrt()
		},
		effDesc(x) {
			return "Reduce the cost scaling of Hyperspace by " + format(Decimal.sub(1, x.recip()).times(100)) + "%"
		}
	},
	10: {
		cost: new Decimal("e9500000"),
		eff(x) {
			return x.max(1).log10().div(5).max(1)
		},
		effDesc(x) {
			return "Super-Upgrades are " + format(x.sub(1).times(100)) + "% stronger"
		}
	},
}

function getSpaceBuildingCostMod() {
	let mod = new Decimal(1)
	if (player.s.upgrades.includes(24)&&!(tmp.challActive?tmp.challActive.h[12]:true)) mod = mod.times(0.5)
	if (player.s.upgrades.includes(42)) mod = mod.times(0.6)
	if (spellActive(4)) mod = mod.times(Decimal.sub(1, tmp.spellEffs[4].sub(1)))
	if (player.ba.upgrades.includes(15)) mod = mod.div(LAYER_UPGS.ba[15].currently())
	return mod;
}

function getSpaceBuildingCostMult() {
	let mult = new Decimal(1)
	if (player.ss.unl) mult = mult.div(tmp.ssEff2)
	if (player.s.upgrades.includes(41)) mult = mult.div(LAYER_UPGS.s[41].currently())
	return mult
}

function getSpaceBuildingCost(x) {
	let inputVal = SPACE_BUILDINGS[x].cost
	let bought = tmp.s.sb[x]
	if (bought.gte(100)) bought = bought.pow(2).div(100)
	let cost = Decimal.pow(inputVal, bought.times(tmp.s.sbCostMod).pow(1.35)).times(inputVal).times((bought.gt(0)||x>1)?1:0).times(tmp.s.sbCostMult)
	return cost
}

function getSpaceBuildingTarg(x) {
	let inputVal = SPACE_BUILDINGS[x].cost
	let target = player.g.power.div(tmp.s.sbCostMult).div(inputVal).max(1).log(inputVal).pow(1/1.35).div(tmp.s.sbCostMod)
	if (target.gte(100)) target = target.times(100).sqrt()
	return target.add(1).floor()
}

function getSpaceBuildingPow() {
	if (!player.s.unl) return new Decimal(0)
	if (tmp.challActive ? tmp.challActive.h[22] : true) return new Decimal(0)
	if (tmp.challActive ? tmp.challActive.h[41] : true) return new Decimal(0)
	let pow = new Decimal(1)
	if (player.s.upgrades.includes(21)&&!(tmp.challActive?tmp.challActive.h[12]:true)) pow = pow.times(LAYER_UPGS.s[21].currently())
	if (player.s.upgrades.includes(22)&&!(tmp.challActive?tmp.challActive.h[12]:true)) pow = pow.times(LAYER_UPGS.s[22].currently())
	if (player.s.upgrades.includes(23)&&!(tmp.challActive?tmp.challActive.h[12]:true)) pow = pow.times(LAYER_UPGS.s[23].currently())
	if (player.s.upgrades.includes(44)&&!(tmp.challActive?tmp.challActive.h[12]:true)) pow = pow.times(1.25)
	if (player.q.upgrades.includes(41)) pow = pow.times(1.4)
	if (player.ss.unl) pow = pow.times(tmp.ssEff3)
	if (player.ba.upgrades.includes(44)) pow = pow.times(1.5)
	return pow
}

function getExtraBuildingLevels() {
	let lvl = new Decimal(0)
	if (player.s.upgrades.includes(11)&&!(tmp.challActive?tmp.challActive.h[12]:true)) lvl = lvl.add(1);
	if (player.s.upgrades.includes(14)&&!(tmp.challActive?tmp.challActive.h[12]:true)) lvl = lvl.add(1);
	if (player.q.upgrades.includes(31)) lvl = lvl.add(1);
	if (player.m.upgrades.includes(32)) lvl = lvl.add(LAYER_UPGS.m[32].currently())
	return lvl
}

function getSpaceBuildingEff(x) {
	let bought
	if (!player.s.unl) bought = new Decimal(0)
	else {
		bought = tmp.s.sb[x].add(tmp.s.sbExtra)
		if (x < 5 && tmp.s.trueSbUnl >= 5) bought = bought.add(tmp.s.sbEff[5])

		var compressLvl = new Decimal(1)
		if (tmp.i !== undefined && layerUnl("i") && tmp.i.compressed >= x) compressLvl = tmp.s.sbUnl.sub(x - SPACE_BUILDINGS.max - 1).div(SPACE_BUILDINGS.max).ceil().cbrt()

		bought = bought.times(tmp.s.sbPow).times(compressLvl)
		if (tmp.hs !== undefined && layerUnl("hs")) {
			tmp.hs.suEff[x] = HYPERSPACE.effs[x](bought, fixValue(tmp.hs.su[x]).times(tmp.hs.eff).times(compressLvl))
			bought = bought.times(tmp.hs.suEff[x])
		}
	}
	return SPACE_BUILDINGS[x].eff(bought)
}

function getSpaceBuildingEffDesc(x) {
	let eff = tmp.s.sbEff[x]
	return SPACE_BUILDINGS[x].effDesc(eff)
}

function buyBuilding(x) {
	if (!player.s.unl) return
	if (tmp.s.trueSbUnl<x) return
	if (getSpace().lt(1)) return
	let cost = getSpaceBuildingCost(x)
	if (player.g.power.lt(cost)) return
	player.g.power = player.g.power.sub(cost)
	addSpaceBuilding(x, 1)
}

function maxSpaceBuilding(x) {
	if (!player.s.unl) return
	if (tmp.s.trueSbUnl<x) return
	let space = getSpace()
	if (space.lt(1)) return
	let target = getSpaceBuildingTarg(x)
	let bulk = target.sub(tmp.s.sb[x]).min(space)
	if (bulk.lt(1)) return
	addSpaceBuilding(x, bulk)
}

function destroyBuilding(x, all=false) {
	if (!player.s.unl) return
	if (tmp.s.trueSbUnl<x) return
	if (tmp.s.sb[x].lt(1)) return
	if (player.q.best.lt(2500)) return
	addSpaceBuilding(x, all ? tmp.s.sb[x].neg() : -1)
}

function addSpaceBuilding(x, amt) {
	amt = getSpace().min(amt)
	player.s.spent = player.s.spent.add(amt)
	tmp.s.sb[x] = tmp.s.sb[x].add(amt)
	player.s.buildings[x] = tmp.s.sb[x]
}

function respecSpaceBuildings() {
	if (!player.s.unl) return;
	if (!confirm("Are you sure you want to reset your Space Buildings? This will force you to do a Space reset as well!")) return
	player.s.buildings = {}
	player.s.spent = new Decimal(0)
	doReset("s", true)
}

function getSpaceBuildingsUnl() {
	let x = 3
	if (player.s.upgrades.includes(14)&&!(tmp.challActive?tmp.challActive.h[12]:true)) x++;
	if (player.s.upgrades.includes(32)&&!(tmp.challActive?tmp.challActive.h[12]:true)) x++;
	if (layerUnl("i")) {
		x = new Decimal(x)
		if (player.i.unl) x = x.add(player.i.extraBuildings)
	}
	return x;
}


function getSuperBoosterPow() {
	if (tmp.challActive ? tmp.challActive.h[41] : true) return new Decimal(0)
	let pow = new Decimal(1)
	if (player.sb.upgrades.includes(11)&&!(tmp.challActive?tmp.challActive.h[12]:true)) pow = pow.times(LAYER_UPGS.sb[11].currently())
	if (player.sb.upgrades.includes(12)&&!(tmp.challActive?tmp.challActive.h[12]:true)) pow = pow.times(LAYER_UPGS.sb[12].currently())
	if (player.hb.upgrades.includes(11)) pow = pow.times(LAYER_UPGS.hb[11].currently())
	return pow;
}

function addToSBBase() {
	let toAdd = new Decimal(0)
	if (player.h.challs.includes(22)) toAdd = toAdd.add(0.25)
	if (player.h.challs.includes(41)) toAdd = toAdd.add(0.25)
	if (player.sb.upgrades.includes(22)) toAdd = toAdd.add(LAYER_UPGS.sb[22].currently())
	if (player.hb.unl) toAdd = toAdd.times(tmp.layerEffs.hb)
	return toAdd
}

function getQuirkLayerCostBase() {
	let base = new Decimal(2)
	if (player.ba.upgrades.includes(31)) base = LAYER_UPGS.ba[31].currently()
	return base
}

function getQuirkLayerCost(layers) {
	if (layers === undefined) layers = player.q.layers
	if (layers.gte(20)) layers = Decimal.pow(1.05, layers.sub(20)).times(20)
	if (player.ba.upgrades.includes(55)) layers = layers.sub(LAYER_UPGS.ba[55].currently())
	let cost = Decimal.pow(tmp.qCB, Decimal.pow(tmp.qCB, layers).sub(1))
	return cost.max(1);
}

function getQuirkLayerTarg() {
	let targ = player.q.points.log(tmp.qCB).add(1).log(tmp.qCB)
	if (player.ba.upgrades.includes(55)) targ = targ.add(LAYER_UPGS.ba[55].currently())
	if (targ.gte(20)) targ = targ.div(20).log(1.05).add(20)
	return targ.add(1).floor()
}

function getQuirkLayerMult() {
	let mult = new Decimal(1)
	if (player.q.upgrades.includes(13)) mult = mult.times(2)
	if (player.q.upgrades.includes(14)) mult = mult.times(3)
	if (player.q.upgrades.includes(21)) mult = mult.times(LAYER_UPGS.q[21].currently())
	if (player.q.upgrades.includes(52)) mult = mult.times(LAYER_UPGS.q[52].currently())
	if (player.h.challs.includes(52)) mult = mult.times(LAYER_CHALLS.h[52].currently())
	if (player.ba.upgrades.includes(13)) mult = mult.times(LAYER_UPGS.ba[13].currently())
	return mult
}

function getExtraQuirkLayers() {
	let layers = new Decimal(0);
	if (player.q.upgrades.includes(51)) layers = layers.add(LAYER_UPGS.q[51].currently())
	if (player.m.upgrades.includes(24)) layers = layers.add(LAYER_UPGS.m[24].currently())
	if (player.m.upgrades.includes(34)) layers = layers.add(1)
	if (tmp.s !== undefined && tmp.s.trueSbUnl >= 8) layers = layers.add(tmp.s.sbEff[8])
	return layers;
}

function getQuirkEnergyGainExp() {
	let mult = new Decimal(1)
	if (spellActive(3)) mult = mult.times(tmp.spellEffs[3])
	return player.q.layers.add(getExtraQuirkLayers()).sub(1).times(mult)
}

function getQuirkEnergyEff() {
	let eff = player.q.energy.add(1).pow(2)
	if (player.q.upgrades.includes(12)) {
		let mod = player.q.energy.add(1).log10().add(1).log10().add(1)
		if (mod.gte(2)) {
			eff = eff.times(mod.div(2).pow(10))
			mod = new Decimal(2)
		}
		eff = eff.pow(mod)
	}
	if (player.q.upgrades.includes(32)) eff = eff.pow(2)
	if (player.h.challs.includes(61)) eff = eff.pow(1.2)
	if (player.ba.upgrades.includes(13)) eff = eff.pow(3)
	return eff;
}

function buyQuirkLayer() {
	if (!player.q.unl) return
	let cost = getQuirkLayerCost()
	if (player.q.points.lt(cost)) return
	player.q.points = player.q.points.sub(cost)
	player.q.layers = player.q.layers.add(1)
}

function maxQuirkLayers() {
	if (!player.q.unl) return
	let cost = getQuirkLayerCost()
	if (player.q.points.lt(cost)) return
	let target = getQuirkLayerTarg()
	if (target.lte(player.q.layers)) return
	player.q.points = player.q.points.sub(cost)
	player.q.layers = player.q.layers.max(target)
}


function getSubspaceEff1() {
	if (!player.ss.unl) return new Decimal(0)
	let eff = player.ss.subspace.times(player.ss.points).add(1).log10().times(100)
	if (player.sp.upgrades.includes(35)) eff = eff.times(LAYER_UPGS.sp[35].currently())
	return eff.floor();
}

function getSubspaceEff2() {
	if (!player.ss.unl) return new Decimal(1)
	let eff = player.ss.subspace.add(1).pow(750)
	if (player.sp.upgrades.includes(35)) eff = eff.pow(LAYER_UPGS.sp[35].currently())
	return eff;
}

function getSubspaceEff3() {
	if (!player.ss.unl) return new Decimal(1)
	let eff = player.ss.subspace.add(1).log10().add(1).log10().div(2.5).add(1)
	if (player.ss.upgrades.includes(13)) eff = eff.times(1.5)
	if (player.sp.upgrades.includes(35)) eff = eff.times(LAYER_UPGS.sp[35].currently())
	if (eff.gte(2)) eff = eff.log2().add(1)
	return eff;
}

function getSubspaceGainMult() {
	let mult = new Decimal(1)
	if (player.ss.upgrades.includes(12)) mult = mult.times(LAYER_UPGS.ss[12].currently())
	if (player.ss.upgrades.includes(22)) mult = mult.times(LAYER_UPGS.ss[22].currently())
	if (player.ss.upgrades.includes(24)) mult = mult.times(LAYER_UPGS.ss[24].currently())
	if (player.ss.upgrades.includes(25)) mult = mult.times(LAYER_UPGS.ss[25].currently())
	if (player.ba.upgrades.includes(12)) mult = mult.times(LAYER_UPGS.ba[12].currently())
	return mult
}

function addToHBBase() {
	let toAdd = new Decimal(0)
	if (player.m.upgrades.includes(13)) toAdd = toAdd.add(LAYER_UPGS.m[13].currently())
	if (player.m.upgrades.includes(33)) toAdd = toAdd.add(LAYER_UPGS.m[33].currently())
	return toAdd
}

function getHyperBoosterExp() {
	let exp = new Decimal(1)
	if (player.hb.order>0) exp = new Decimal(0.5)
	return exp
}

function getExtraHyperBoosters() {
	let x = new Decimal(0)
	if (player.l.unl && tmp.l !== undefined) x = x.add(tmp.l.lbEff[1])
	return x
}

function getHyperBoosterPow() {
	let pow = new Decimal(1)
	if (player.hb.upgrades.includes(12)) pow = pow.times(LAYER_UPGS.hb[12].currently())
	return pow;
}

function getBalancePowerEff() {
	let eff = player.ba.power.times(2).add(1).pow(2/3)
	if (player.ba.upgrades.includes(14)) eff = eff.pow(3.85)
	if (player.ba.upgrades.includes(33)) eff = eff.pow(2)
	return eff;
}

function getBalanceTypesEff() {
	let mod = player.ba.positivity.add(1).log10().add(1).div(player.ba.negativity.add(1).log10().add(1)).log10().abs().add(1).pow(-1)
	let pos = player.ba.positivity.add(1).log10().add(1)
	let neg = player.ba.negativity.add(1).log10().add(1)
	if (player.ba.upgrades.includes(34)) mod = mod.times(1.5)
	if (player.ba.upgrades.includes(53)) mod = mod.times(LAYER_UPGS.ba[53].currently())
	let eff = pos.times(neg).pow(mod)
	return eff;
}

function getBalanceEnergyExp() {
	let exp = new Decimal(1)
	if (player.ba.unl) exp = exp.times(1.5)
	return exp;
}

function getPosGainMult() {
	let mult = new Decimal(1)
	if (player.ba.upgrades.includes(22)) mult = mult.times(LAYER_UPGS.ba[22].currently())
	return mult;
}

function getNegGainMult() {
	let mult = new Decimal(1)
	if (player.ba.upgrades.includes(22)) mult = mult.times(LAYER_UPGS.ba[22].currently())
	return mult;
}

function getBalPowGainMult() {
	let mult = new Decimal(1)
	if (player.sp.upgrades.includes(14)) mult = mult.times(LAYER_UPGS.sp[14].currently())
	return mult;
}


const MAX_SPELLS = 4

const SPELL_NAMES = {
	1: "Booster Launch",
	2: "Time Warp",
	3: "Quirk Amplification",
	4: "Spacial Compression",
}

const SPELL_DESCS = {
	1: "Boosters are X% stronger",
	2: "Time Capsules are X% stronger",
	3: "Quirk Layers are X% more efficient",
	4: "Space Buildings cost scale X% slower",
}

const SPELL_BASE = {
	1: 1.25,
	2: 1.1,
	3: 1.04,
	4: 1.01,
}

function getSpellPower(x) {
	let power = new Decimal(1);
	if (player.m.upgrades.includes(11)) power = power.times(LAYER_UPGS.m[11].currently())
	if (player.m.upgrades.includes(21) && (x==2||x==3)) power = power.times(LAYER_UPGS.m[21].currently())
	if (player.m.upgrades.includes(22) && (x==2)) power = power.times(10)
	if (player.m.upgrades.includes(41)) {
		let casted = player.m.casted[x]
		power = power.times(casted.max(1).log10().add(1).log10().div(5).add(1))
	}
	if (player.sp.upgrades.includes(23)) power = power.times(LAYER_UPGS.sp[23].currently())
	if (player.ps.upgrades.includes(13)) power = power.times(LAYER_UPGS.ps[13].currently())
	
	if (power.gte(50)) power = power.log10().times(50/Math.log10(50)).min(power)
	return power.max(1);
}

function getSpellEff(x) {
	let base = SPELL_BASE[x]
	let power = getSpellPower(x)
	let eff = Decimal.pow(base, power)
	if (x==4) eff = Decimal.sub(2, Decimal.div(base, power.log2().add(1)))
	return eff
}

function getSpellDesc(x) {
	let desc = SPELL_DESCS[x]
	let eff = tmp.spellEffs[x]
	return desc.replace("X", format(eff.sub(1).times(100)))
}

function getSpellTime() {
	let time = 60
	if (player.m.total.gte(2.5e9)) time *= 4
	if (player.m.upgrades.includes(43)) time *= LAYER_UPGS.m[43].currently().toNumber()
	return time
}

function spellActive(x) {
	if (!player.m.unl) return false
	if (!tmp.spellEffs) return false
	if (tmp.spellsUnl<x) return false
	return player.m.spellTimes[x]>0
}

function activateSpell(x, force=false) {
	if (tmp.spellsUnl<x) return;
	let toCast = setToCast(player.m.toCast[x]).max(1)
	if (!force) {
		if (!player.m.unl) return
		if (spellActive(x)) return
		if (player.m.points.lt(toCast)) return
	}
	if (player.sp.total.lt(2)) player.m.points = player.m.points.sub(toCast).max(0)
	player.m.casted[x] = toCast
	player.m.spellTimes[x] = getSpellTime()
	if (!force) player.m.hexes = player.m.hexes.add(getHexGain())
}

function getHexGain() {
	let gain = new Decimal(1)
	if (player.m.upgrades.includes(14)) gain = gain.times(LAYER_UPGS.m[14].currently())
	if (player.sp.upgrades.includes(14)) gain = gain.times(LAYER_UPGS.sp[14].currently())
	if (player.l.unl && tmp.l !== undefined) gain = gain.times(tmp.l.lbEff[2])
	return gain.floor()
}

function getHexEff() {
	let eff = player.m.hexes.times(2).max(1).pow(5)
	return eff;
}

function isToCastValid(val) {
	try {
		val = new Decimal(val).floor()
		if (val.eq(undefined) || val.eq(null)) return false
		if (val.lt(1)) return false
		if (val.gt(player.m.points)) return false
		return val;
	} catch(e) {
		return false;
	}
}

function setToCast(val) {
	if (!player.m.upgrades.includes(41)) return new Decimal(1)
	let validVal = isToCastValid(val)
	if (!validVal) return new Decimal(1)
	else return validVal
}

function updateToCast(id) {
	activateSpell(id, true)
}

function getSGenPowEff() {
	if (!player.sg.unl) return new Decimal(1)
	let eff = player.sg.power.add(1).pow(3)
	return eff
}

function getSuperGenPowerGainMult() {
	let mult = new Decimal(1)
	if (player.ba.upgrades.includes(21)) mult = mult.times(LAYER_UPGS.ba[21].currently())
	return mult
}

function addToSGBase() {
	let toAdd = new Decimal(0)
	if (player.ba.upgrades.includes(23)) toAdd = toAdd.add(LAYER_UPGS.ba[23].currently())
	if (player.sp.upgrades.includes(21)) toAdd = toAdd.add(LAYER_UPGS.sp[21].currently())
	return toAdd
}

function getLifePowerMult() {
	let x = tmp.layerEffs.ps.mult.div(30)
	if (player.sp.upgrades.includes(42)) x = x.times(LAYER_UPGS.sp[42].currently())
	if (tmp.s !== undefined && tmp.s.trueSbUnl >= 6) x = x.times(tmp.s.sbEff[6])
	return x
}

function getLifePowerExp() {
	let x = tmp.layerEffs.ps.exp
	return x
}

function getLifePowerSoftcapStart() {
	let x = tmp.layerEffs.l
	return x
}

function getLifePowerSoftcapExp() {
	let x = 1/3
	return x
}

let LIFE_BOOSTERS = {
	max: 5,
	unl() {
		if (player.ps.upgrades.includes(21)) return 5
		return 4
	},
	calcNewPower(diff) {
		if (!player.l.unl) return new Decimal(0)

		let exp = getLifePowerExp()
		let cap = getLifePowerSoftcapStart()
		let capExp = getLifePowerSoftcapExp()

		let power = player.l.power
		if (power.gt(1)) power = power.root(exp)
		if (power.gt(cap)) power = power.div(cap).pow(1/capExp).times(cap)
		power = power.add(getLifePowerMult().times(diff))
		if (power.gt(cap)) power = power.div(cap).pow(capExp).times(cap)
		if (power.gt(1)) power = power.pow(exp)

		return power
	},
	eff() {
		return player.l.power.add(1).log10()
	},
	req(x) {
		return tmp.l.lb[x].times(this[x].reqMult).add(this[x].req)
	},
	reqTarget(x) {
		return player.ps.points.sub(this[x].req).div(this[x].reqMult).add(1).floor()
	},
	1: {
		req: new Decimal(1),
		reqMult: new Decimal(1),
		eff(str) {
			return str.pow(0.15).div(3)
		},
		effDesc(x) {
			return "Add " + format(x) + " Hyper-Boosters to its effect"
		}
	},
	2: {
		req: new Decimal(1.5),
		reqMult: new Decimal(1.5),
		eff(str) {
			let x = Decimal.pow(1e20, str.pow(0.75))
			if (x.gte("1e400")) x = Decimal.pow(10, x.log10().times(400).sqrt())
			return x
		},
		effDesc(x) {
			return "Gain " + format(x) + "x more Hexes"
		}
	},
	3: {
		req: new Decimal(3.5),
		reqMult: new Decimal(2.5),
		eff(str) {
			return str.div(1.5).max(1).log10().add(1)
		},
		effDesc(x) {
			return "Multiply the base of Time Capsule effect by " + format(x) + "x"
		}
	},
	4: {
		req: new Decimal(10),
		reqMult: new Decimal(3),
		eff(str) {
			return str.div(40).add(1)
		},
		effDesc(x) {
			return "Reduce the requirement of Super-Boosters, Super-Generators, and Hyper-Boosters by " + format(x) + "x"
		}
	},
	5: {
		req: new Decimal(5),
		reqMult: new Decimal(6),
		eff(str) {
			return Decimal.pow(3, str.sqrt())
		},
		effDesc(x) {
			return "Gain " + format(x) + "x more Hyperspace Energy"
		}
	},
}

let HYPERSPACE = {
	cost(x) {
		if (x === undefined) x = player.hs.space
		if (tmp.s !== undefined && tmp.s.trueSbUnl >= 9) x = x.div(tmp.s.sbEff[9])
		let reduction = this.costReduction()
		return {
			hs: Decimal.pow(2, x.sqr()).div(reduction).floor(),
			ba: Decimal.pow(10, x.max(x.div(2).sqr()).times(20).add(150)).div(reduction).floor()
		}
	},
	costReduction() {
		let r = new Decimal(1)
		if (player.ba.upgrades.includes(45)) r = LAYER_UPGS.ba[45].currently()
		return r
	},
	canBuy() {
		let cost = this.cost()
		return player.hs.points.gte(cost.hs) && player.ba.points.gte(cost.ba)
	},
	buy() {
		let cost = this.cost()
		if (!this.canBuy()) return
		player.ba.points = player.ba.points.sub(cost.ba)
		player.hs.points = player.hs.points.sub(cost.hs)
		player.hs.space = player.hs.space.add(1)
	},
	canSuperUpg(x) {
		return player.hs.space.gt(player.hs.spent) && tmp.hs.su[x].lt(player.hs.superUpgradeCap)
	},
	superUpg(x) {
		if (!this.canSuperUpg(x)) return
		player.hs.spent = player.hs.spent.add(1)
		tmp.hs.su[x] = tmp.hs.su[x].add(1)
		player.hs.superUpgrades[x] = tmp.hs.su[x]
	},
	respec(x) {
		if (!player.hs.unl || !confirm("Are you sure?")) return
		player.hs.spent = new Decimal(0)
		player.hs.superUpgrades = {}
		doReset("hs", true)
	},
	eff() {
		let r = new Decimal(1)
		if (player.ba.upgrades.includes(35)) r = r.times(1.25)
		if (tmp.s !== undefined && tmp.s.trueSbUnl >= 10) r = r.times(tmp.s.sbEff[10])
		return r
	},
	nextCapReq(x) {
		if (x === undefined) x = player.hs.superUpgradeCap
		return Decimal.times(x, 200).add(1300)
	},
	nextCapTarget() {
		let x = player.g.points.sub(1300).div(200)
		return x.floor().add(1)
	},
	effs: {
		1(sb, su) {
			return sb.add(1).pow(su.sqrt().times(2.5))
		},
		2(sb, su) {
			return sb.pow(0.25).times(su.sqrt()).div(120).add(1)
		},
		3(sb, su) {
			return sb.cbrt().times(su.sqrt()).times(0.75).add(1)
		},
		4(sb, su) {
			return Decimal.pow(2.5, sb.cbrt().times(su.sqrt()))
		},
		5(sb, su) {
			return sb.add(10).log10().times(su.sqrt()).div(1.75).max(1)
		},
		6(sb, su) {
			return Decimal.pow(sb.div(1e3).add(1), su)
		},
		7(sb, su) {
			return sb.add(1).log10().times(su.cbrt()).div(25).add(1)
		},
		8(sb, su) {
			return sb.times(su.sqr()).div(100).max(1).log10().add(1)
		},
		9(sb, su) {
			return sb.times(su).max(1).log10().add(1)
		},
		10(sb, su) {
			return sb.add(1).pow(su.cbrt().div(5))
		}
	}
}


let IMPERIUM = {
	lifeReq() {
		return Decimal.pow(10, player.i.lifeBricks.times(2).sqr().add(15))
	},
	lifeTarget() {
		return player.l.power.log10().sub(15).sqrt().div(2).add(1).floor()
	},
	canBuild() {
		let cost = this.cost()
		return player.i.building || (player.i.points.gte(cost.i) && player.i.lifeBricks.gte(cost.l))
	},
	build() {
		if (!this.canBuild()) return
		if (player.i.building) {
			if (!confirm("Are you sure?")) return
			delete player.i.building
		} else {
			let cost = this.cost()
			player.i.points = player.i.points.sub(cost.i)
			player.i.lifeBricks = player.i.lifeBricks.sub(cost.l)
			player.i.building = 1
			doReset("i", true)
		}
		player.i.progress = 0
	},
	cost(x) {
		if (x === undefined) x = player.i.extraBuildings
		let sub = player.sp.upgrades.includes(45) ? 3 : 0
		return {
			i: x.times(1.75).add(0.5).sub(sub).ceil(),
			l: x.times(1.5).add(1).sub(sub).ceil()
		}
	},
	speed() {
		let x = Decimal.pow(3.75, player.i.extraBuildings.add(5)).recip()
		x = x.times(IMPERIUM.sgSpeedBoost())
		if (player.sp.upgrades.includes(45)) x = x.times(5)
		return x
	},
	sgSpeedBoost() {
		return player.sg.points.add(1).pow(2)
	},
	collapsed(row) {
		return tmp.i !== undefined && tmp.i.collapse !== undefined && tmp.i.collapse[row]
	},
	maxCollapseRows: 1
}

/*case 1: 
			var keepUpgrades = 0
			if (player.h.best.gte(1) || player.q.best.gte(1)) keepUpgrades = 1
			else if (LAYER_ROW[layer] == 2 && player[layer].best.gte(layer == "e" ? 10 : 3)) keepUpgrades = 1
			else if (LAYER_ROW[layer] == 1 && player[layer].best.gte(8)) keepUpgrades = 1

			player.points = new Decimal(10)
			player.p.points = new Decimal(0)
			if (!keepUpgrades) player.p.upgrades = []
			player.g.power = new Decimal(0)
			break;
		case 2: 
			var keepMilestones = 0
			if (player.h.best.gte(2) || player.q.best.gte(2)) keepMilestones = 1
			else if (LAYER_ROW[layer] == 2 && player[layer].best.gte(layer == "sb" ? 4 : 2)) keepMilestones = 1

			var keepUpgrades = 0
			if (player.sp.total.gte(1)) keepUpgrades = 1

			player.b.points = new Decimal(0)
			if (!keepMilestones) player.b.best = new Decimal(0)
			if (!keepUpgrades && !player.t.best.gte(4)) player.b.upgrades = []

			player.g.points = new Decimal(0)
			player.g.power = new Decimal(0)
			if (!keepMilestones) player.g.best = new Decimal(0)
			if (!keepUpgrades && !player.s.best.gte(4)) player.g.upgrades = []

			player.t.energy = new Decimal(0)
			break
		case 3: 
			player.t.points = new Decimal(0);
			player.t.order = 0
			if (player.h.best.lt(2)&&player.m.total.lt(1)) player.t.best = new Decimal(0);
			if (player.h.best.lt(4)&&!player.sp.total.gte(1)) player.t.upgrades = [];
			player.t.extCapsules = new Decimal(0);
			player.e.order = 0
			player.e.points = new Decimal(0);
			if (player.h.best.lt(2)&&player.m.total.lt(1)) player.e.best = new Decimal(0);
			player.e.enhancers = new Decimal(0);
			if (player.h.best.lt(4)&&!player.sp.total.gte(1)) player.e.upgrades = [];
			player.s = {
				unl: player.s.unl,
				order: 0,
				points: new Decimal(0),
				best: (player.h.best.gte(2)||player.m.total.gte(1)) ? player.s.best : new Decimal(0),
				spent: (player.q.best.gte(4)&&(layer=="h"||layer=="q"||layer=="ss"||layer=="hb")) ? player.s.spent : new Decimal(0),
				buildings: (player.q.best.gte(4)&&(layer=="h"||layer=="q"||layer=="ss"||layer=="hb")) ? player.s.buildings : ({}),
				upgrades: (player.h.best.gte(4)||player.sp.total.gte(1)) ? player.s.upgrades : [],
				auto: player.s.auto,
				autoBuild: player.s.autoBuild,
			}
			player.sb = {
				unl: player.sb.unl,
				auto: player.sb.auto,
				order: 0,
				points: new Decimal(0),
				best: (player.h.best.gte(2)||player.m.total.gte(1)) ? player.sb.best : new Decimal(0),
				upgrades: (player.h.best.gte(10)||player.sp.total.gte(1)) ? player.sb.upgrades : [],
			}
			player.sg = {
				unl: player.sg.unl,
				auto: player.sg.auto,
				points: new Decimal(0),
				best: player.sg.best,
				power: new Decimal(0),
				upgrades: player.sg.upgrades,
			}
			player.h.time = 0
			player.q.time = new Decimal(0);
			player.q.energy = new Decimal(0);
			break;
		case 4: 
			player.h = {
				unl: player.h.unl,
				time: 0,
				points: new Decimal(0),
				best: (player.ba.best.gte(1)||player.m.total.gte(1))?player.h.best:new Decimal(0),
				challs: (player.m.total.gte(2)||player.sp.total.gte(1))?player.h.challs:[],
			}
			player.q = {
				unl: player.q.unl,
				auto: player.q.auto,
				points: new Decimal(0),
				best: (player.ba.best.gte(1)||player.m.total.gte(1))?player.q.best:new Decimal(0),
				layers: new Decimal(0),
				energy: new Decimal(0),
				time: new Decimal(0),
				upgrades: (player.ba.best.gte(2)||player.sp.total.gte(1))?player.q.upgrades:[],
			}
			player.hb = {
				unl: player.hb.unl,
				auto: player.hb.auto,
				order: player.hb.order,
				points: new Decimal(0),
				best: (player.ba.best.gte(1)||player.m.total.gte(1))?player.hb.best:new Decimal(0),
				upgrades: (player.ba.best.gte(5)||player.sp.total.gte(1))?player.hb.upgrades:[],
			}
			player.ss = {
				unl: player.ss.unl,
				auto: player.ss.auto,
				order: player.ss.order,
				points: new Decimal(0),
				best: (player.ba.best.gte(1)||player.m.total.gte(1))?player.ss.best:new Decimal(0),
				subspace: new Decimal(0),
				upgrades: (player.ba.best.gte(5)||player.sp.total.gte(1))?player.ss.upgrades:[],
			}
			break;
		case 5: 
			player.m = {
				unl: player.m.unl,
				auto: player.m.auto,
				autoIns: player.m.autoIns,
				points: new Decimal(0),
				best: new Decimal(0),
				total: player.sp.total.gte(2) ? player.m.total : new Decimal(0),
				spellTimes: {
					1: 0,
					2: 0,
					3: 0,
					4: 0,
				},
				hexes: new Decimal(0),
				toCast: player.m.toCast,
				casted: {
					1: new Decimal(1),
					2: new Decimal(1),
					3: new Decimal(1),
					4: new Decimal(1),
				},
				upgrades: player.sp.total.gte(1) ? player.m.upgrades : [],
			}
			player.ba = {
				unl: player.ba.unl,
				points: new Decimal(0),
				best: player.sp.total.gte(5) ? player.ba.best : new Decimal(0),
				power: new Decimal(0),
				positivity: new Decimal(0),
				negativity: new Decimal(0),
				upgrades: player.sp.total.gte(1) ? player.ba.upgrades : [],
			}
			player.ps = {
				unl: player.ps.unl,
				auto: player.ps.auto,
				points: new Decimal(0),
				best: player.ps.best,
				upgrades: player.ps.upgrades,
			}
			player.l.power = new Decimal(0)
			break;
		case 6:
			var start = getStartPlayer()
			player.sp = start.sp
			player.l = start.l
			player.hs = start.hs
			player.i = start.i
			break;*/