This is the new ex­pres­sion for prestige. It looks in­tim­id­at­ing, but it will work nor­mally and you never have to turn it off (you would have to if you did­n’t use this one later on). Here is an ex­plan­a­tion for all parts ex­cept the nor­mal ex­pres­sion which has an ex­plan­a­tion already.

((d(smooth(10^10^10^(phi * tau), 1)) > 1

This re­turns true if phi and/​or tau grows a very very small amount more than the max reached that prestige. The many “10^” is to make any tiny changes ex­plode into very large num­bers so that they will never be less than 1, es­pe­cially if you are far into a gradu­ation or en­dgame. This also pre­vents you from early pres­ti­ging from drop­ping ac­cel or mov­ing stu­dents around as they make phi drop in value.

timer(abs(d(lo­g10(phi + 1))) < 50) > 15))

This part pre­vents pres­ti­ging if phi were to change by more than e5 within 1 tick. It will then wait 15 seconds be­fore check­ing if it can prestige again. This will al­low you to swap R9 or stu­dents freely without need­ing to worry about ac­ci­dent­ally pres­ti­ging for a very small amount of .

|| phi <= 1 ||

If phi is equal to 1, then it uses the nor­mal auto­prestige ex­pres­sion. We don’t have “=” in the ex­pres­sions, so we had to work around it by us­ing <= (less than). Phi can never be less than 1 so if , . This means that, even if you don’t have any phi up­grades, it will al­low you to prestige like nor­mal and not re­quire you to swap out of the­or­ies (or R9 un­til the end of a gradu­ation).

(0.8 * lo­g10(lo­g10(lf)) > lo­g10(lo­g10(gf)) ||
0.8 * lo­g10(lo­g10(gf)) > lo­g10(lo­g10(sf))))

This lets the nor­mal ex­pres­sion work when you su­prem­acy or gradu­ate up to 80% of al­low­ing you to re­cover faster than nor­mal. The part of the ex­pres­sion above does not al­low the nor­mal ex­pres­sion to prestige for 15 seconds after a gradu­ation or prestige, be­cause phi can, and will, grow more than e5 in 1 tick. So, we al­low the nor­mal ex­pres­sion to work like nor­mal while re­cov­er­ing.

Ref­er­ence Cu­mu­lat­ive Max­imum Smooth()

Note: If you don’t know what R9 is, you will find out later in the game

Do a manual su­prem­acy when you in­put this ex­pres­sion and never enter the edit ex­pres­sion field again af­ter­wards. Make sure auto­buy­ers are on x1 or xMax.

Copy Equa­tion Text

dpsi + psi > min(cos­tUpS(1),
cos­tUpS(2), cos­tUpS(3))
&& (((lf < ee48000)
&& ((lo­g10(lo­g10(gf)) >=
lo­g10(lo­g10(lf))-400)
|| ((lo­g10(lo­g10(gf)) >=
lo­g10(lo­g10(lf)) * 0.8)
&& (((dpsi + psi > cos­tUpS(1, 3))
|| (dpsi + psi >
(cos­tUpS(2) + cos­tUpS(1, 2))))
|| ((lo­g10(lo­g10(gf)) >=
lo­g10(lo­g10(lf))-10000)
&& (dpsi + psi > cos­tUpS(3, 3)))
|| ((lo­g10(lo­g10(gf)) >=
lo­g10(lo­g10(lf))-4000)
&& (dpsi + psi > cos­tUpS(3, 2)))
|| ((lo­g10(lo­g10(gf)) >=
lo­g10(lo­g10(lf))-1000)
&& (dpsi + psi > cos­tUpS(3, 1)))))
|| ((lo­g10(lo­g10(gf)) <
lo­g10(lo­g10(lf)) * 0.8)
&& (timer(d(ln(db / b + 1) / pt) < 0)
> 3 * tr && db > b
&& dpsi + psi > min(cos­tUpS(1),
cos­tUpS(2), cos­tUpS(3))
&& ln(1 + max(1, lo­g10(sf)) /
smooth(max(1, lo­g10(gf)),
(st > tr) * ee99)) /
max(1, st) <
smooth(ln(1 + max(1, lo­g10(sf)) /
smooth(max(1, lo­g10(gf)),
(st > tr) * ee99)) /
max(1, st), (pt > tr) * ee99)))))
|| ((lf >= ee48000)
&& (((lf < ee52000)
&& ((cos­tUpS(3) < e411
&& psi + dpsi > e411)
|| (cos­tUpS(3) < e531
&& psi + dpsi > e531)
|| (cos­tUpS(3) < e551
&& psi + dpsi > e551)))
|| ((lf < ee58000)
&& (cos­tUpS(3) < e511
&& psi + dpsi > e511))))
|| ((lf < ee75000)
&& (cos­tUpS(3) < e571
&& psi + dpsi > e571))
|| (cos­tUpS(1) < e52
&& psi + dpsi > 4.2e51))

Ref­er­ence Lock­ing Smooth()

Ref­er­ence True/False auto ex­pres­sion eval­u­ation

Auto­su­prem­acy works the same as auto­prestige, but more com­plic­ated due to the stair­case nature of su­prem­acy pro­gress. This is due to it not pro­gress­ing un­less max dur­ing that su­prem­acy is in­creased, but due to prestiges, this is­n’t be­ing pushed dur­ing prestige re­cov­ery which is why we use smooth() lock­ing and gen­eral smooth() to mit­ig­ate this phe­nomenon. The auto­su­prem­acy also is lined up with the end of a prestige so that we get the max­imum amount of out of that prestige to make sure it is time to su­prem­acy.

Your star dis­tri­bu­tion does not need to be up­dated the most of­ten but should be done if it has been a while since you last did. A good rule of meas­ure­ment is every ee1000 to ee2000 gain to your highest reached , as any closer between breaks nor­mally won’t be sig­ni­fic­ant enough. The ex­cep­tion to this is dur­ing the ee6000 push which, sim­ilar to the ee5000 push, re­dis­tri­bu­tion can be handy as it is a long push.

Be­cause of replit changes, you can no longer simply click play and it runs the cal­cu­lator (linked above). You can still use it, but it will be through the fol­low­ing steps:

1. Make a replit ac­count (or lo­gin to an ex­ist­ing ac­count).
2. Fork the gradu­ation cal­cu­lator.
3. On the fork you made, go to the shell ter­minal.
4. Type in the com­mand be­low to start the cal­cu­lator:

py­thon main.py

Copy Text

5. Use the cal­cu­lator as you would pre­vi­ously.