Probably the largest number I've ever defined (inspired by Loader's Number)

U(x,y,z)=U(U(x,y,z-1),y-1,U(x,y,z-1)), U(x,0,z)=x^(z). U(x,y,0)=x (Takes priority over U(x,0,z) if you have the case U(x,0,0)). U is approximately f_y in the FGH.

S(x,y,z) is the result of the following algorithm:

1. Set Sn to U(U(x,x,x),U(y,y,y),U(z,z,z)), starting at S0.
2. Replace all x's, y's, z's in the formula with U(Sn,x,Sn), U(Sn,y,Sn), U(Sn,z,Sn) respectively and increments the S-index for the formula for step 1. Repeat until you are at S0 S'ses, with the index of the last S being 0, then return that.

Assuming S0=2 (Far larger however, I'm just doing it to make the calculations short), for S(2,2,2), we do this:
Set S1 to U(U(U(2,2,2),U(2,2,2),U(2,2,2)),U(U(2,2,2),U(2,2,2),U(2,2,2)),U(U(2,2,2),U(2,2,2),U(2,2,2)).

U(2,2,2)=U(U(2,2,1),1,U(2,2,1))

U(2,2,1)=U(U(2,2,0),1,U(2,2,0))=U(2,1,2)=U(U(2,1,1),0,U(2,1,1))

U(2,1,1)=U(U(2,1,0),0,U(2,1,0))=U(2,0,2)=4

U(2,2,1)=U(4,0,4)=256

U(2,2,2)=U(256,0,256)=2^(2048)=X.

U(U(X,X,X),U(X,X,X),U(X,X,X)) is S1.

We now have to set SS0 (aka S2) to U(U(U(S1,n,S1),U(S1,n,S1),U(S1,n,S1)),U(U(S1,n,S1),U(S1,n,S1),U(S1,n,S1)),U(U(S1,n,S1),U(S1,n,S1),U(S1,n,S1)).

If S0=3, we would stop at SSS0.

S is not that much stronger than U.

T(x,y,z,w) is the same as S(x,y,z) but instead of U, it uses T with w being decremented, where w=0 is S.

T is also not that much stronger than S.

P(x,y,z,w) is the max value you can obtain in a programming language compiler which fits within 2^10z bytes with the target language being assembly language, with x characters in the computation of the number excluding parentheses (The computation of Loader's number in C, D(D(D(D(D(99))))), would have 7 characters, so Loader's number fits within 7 characters in the computation), y functions, and each function can take up at max 2^10z bytes of data in the definitions of such as well, including w variables and oracles. P(x,y,z,0) is uncomputable, and because of such, dominates any computable function, because assembly language is Turing complete, and can simulate any computable function, even without oracles.

P is far more powerful than T, S, and U combined, even more powerful than Xi and BB combined even.

M(x) is the maximum amount of steps an x state, x symbol, x memslot, x oracle halting MTM (Memory Turing Machine) can take without halting.

An MTM is a TM which has memory slots (memslots) which the TM can access at any time and can dictate its behavior. It can access a specific memslot or multiple specific memslots (say S5 or R5 corresponding to memslot 5, R[1,5] or corresponding to memslots 1 and 5, and RA corresponding to all memslots). An S means you set that specific memslot to the current read symbol on the tape (S can only be applied to one memslot), R means you read those memslots.

P1(x)=P(x,x,x,x), U1(x)=U(x,x,x), S1(x)=S(x,x,x), T1(x)=T(x,x,x,x).

W(x)=P1^(M^P1(U1^S1(W(x-1))(W(x-1)))(W(x-1))(W(x-1)))(W(x-1)), W(0)=P1^(P1(10))(10).

My number, which I call "OneShot", yes I named it after the game, screw you, is W^(W(10^100))(10^100).