{a,b,c,d,e} = a [[[[[[....[[[[{{{{{{.....{{{{c}}}}.....}}}}}}]]]]....]]]]]] b  with d {} pairs and e1 [] pairs!
I also have alternative functions, here are "array operator" and "ordinal operator" notations for {a,b,c,d,e}:
{a,b,c,d,e} = a {c,d,e} b = a {w^{2}(e1)+w(d1)+c} b
As before here are the general rules to Array Notation for reference.
Definitions:
Array  a structured set of entries (the array will be represented as A)
Entry  a position in the array that holds a positive integer value (1 is default  so any entry not represented automatically has the value of 1)
Base  first entry (value represented by b)
Prime entry  second entry (value represented by p)
Pilot  first non1 entry after prime entry (can be as early as 3rd entry, can be in a different dimension or beyond)
Copilot  entry right before pilot (if pilot is the first entry on its row, then there's no copilot. Copilot might be the prime entry itself, if the pilot is 3rd entry.
Structures  structures are subarrays of the following types: entry (X^0), row (X^1), plane (X^2), realm (X^3), flune (X^4),..,X^n,..,dimensional group (X^X)=X^^2,..,nD array of dimensional groups (X^(X+n)),..dimensional group of dimensional groups (X^(2X)),...X^(2X+n),...mD array of dim.group of dim.group of.....dim.groups n times (X^(nX+m)),...dimensional gang (X^(X^2)),...X^(polynomial),...X^(X^X)=X^^3,....X^(X^X+polynomial),........X^^4,....X^^n,...X^^X,......X^^^X,....X^^^^````^^^X,...etc.
Previous Structures  previous entries are entries before the pilot but are on the same row, previous rows are rows before the pilot's row, but are in the same plane, previous nspaces are nspaces in the same n+1space that are before the pilot's nspace, etc. They are structures before the pilot's version of that structure, but on the same structure that is of higher order.
Prime Block  the prime block of an X^n structure is the first p^n block of entries in that structure,  this generalizes to all structures, turning the X's to p's, where p is the prime.  so if p=10, and the structure is X^(3X^5+2X^4+3X+6), the prime block is the first 10^(3*10^5+2*10^4+3*10+6) set of entries.
Airplane  a set of entries that include the pilot, all previous entries, and the prime block of all previous structures.
Passengers  any entry in the airplane that is not the pilot or copilot. This will always include the base.
Allowance: Default entries (entries that have a 1 value) can be chopped off as long as none of the entries change their positions.
Rules:
Rule 1  the prime rule  Condition: default prime (p = 1)  Result: v(A)=b. where v(A) means value of array.
Rule 2  the initial rule  Condition: no pilot  Result: v(A)=b^p.
Rule 3  the catastrophic rule  Condition: first two rules don't apply  Result: Array changes in the following way:
a) pilot decreases by 1. b) copilot (if exists) becomes original array, but with its prime entry reduced by 1. c) passengers take on base value. d) remainder of array remains unchanged.We can take the above rules and rewrite them for a 5 entry linear array {a,b,c,d,e}. The pilot could be in positions 2, 3, or 4 which are c, d, and e in our example (starting position is at position 0)  if c = 1, d = 1, and e = 1 then there's no pilot. If c = 1, d = 1, and e > 1 then e is the pilot, d is the copilot, and a,b, and c are the passengers. If c = 1 and d > 1, then d is the pilot, c is the copilot, and the passengers are a and b. If c > 1 regardless of what d or e is, then c is the pilot, b (the prime) is the copilot, and a is the passenger. Since pententrical arrays are linear then the only previous structures are previous entries, and the prime block of an entry is the entry itself  couple this info with the definition of airplane, then we can see that the airplane would all the entries from a to the pilot. So lets see how this changes the rules:
Rule 1 (b=1)  {a,1,c,d,e} = a
Rule 2 (no pilot)  {a,b,1,1,1} = a^{b}  essentially a two entry array
Rule 3a (pilot at e)  {a,b,1,1,e} = {a,a,a,{a,b1,1,1,e},e1}
Rule 3b (pilot at d)  {a,b,1,d,e} = {a,a,{a,b1,1,d,e},d1,e}
Rule 3c (pilot at c)  {a,b,c,d,e} = {a,{a,b1,c,d,e},c1,d,e}
When e = 1 then rule 3a is not needed since the pilot e needs to be greater than 1 for this rule. Rule 1 becomes {a,1,c,d,1} = a, also notice that for tetrentrical arrays {a,1,c,d} = a, so {a,1,c,d,1} = {a,1,c,d} = a. Rule 2 is the same  but notice that {a,b,1,1} = a^{b} also, so {a,b,1,1,1} = {a,b,1,1}, this is also equal to {a,b}. For rule 3b, we have {a,b,1,d,1} = {a,a,{a,b1,1,d,1},d1,1}. Rule 3c becomes {a,b,c,d,1} = {a,{a,b1,c,d,1},c1,d,1}. If we follow this through we will find out that {a,b,c,d,1} = {a,b,c,d} this is 1cropping. So when e = 1, we get the 4 entry arrays again.
When d = 2, then rule 1 becomes {a,1,c,d,2} = a. Rule 2 in not needed, rule 3a becomes {a,b,1,1,2} = {a,a,a,{a,b1,1,1,2},1} = {a,a,a,{a,b1,1,1,2}}. Rule 3b becomes {a,b,1,d,2} = {a,a,{a,b,c1,d,2},d1,2}. Rule 3c becomes {a,b,c,d,2} = {a,(a,b1,c,d,2},c1,d,2}. Lets examine rule 3a a bit closer:
{a,b,1,1,2} = {a,a,a,{a,b1,1,1,2}} = a {{{{{{......{{{{{{a}}}}}}......}}}}}} a  where there are {a,b1,1,1,2} pairs of {} (this is in operator notation)  did I just hear someone scream?
Solving it completely leads to the following  where each level after the first has 'number on previous level' pairs of {}:
a

a {{{{......{{{{{a}}}}}......}}}} a

a {{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}} a

a {{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} a
:
:
:
go all the way to the b'th level!!!
:

a {{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} a
Yep I did hear someone scream, and they ain't stopping!  AAAAHHHHHH!!!!
We can even define the above as a [{1}] b in extended operator notation, we are now using two types of brackets.
a [{0}] b = a {{{{....{{{{a}}}}....}}}} a  with b {}  the [{0}] operator grows at the speed of w^{2} on the FGH (Fast Growing Hierarchy).
a [{1}] b = a [{0}] a [{0}] a [{0}] a [{0}]......[{0}] a  a [{0}]'ed to itself b times. The [{1}] operator grows at the speed of w^{2}+1 on the FGH.
a [{2}] b = a [{1}] a [{1}] a [{1}] a [{1}]......[{1}] a  a [{1}]'ed to itself b times. The [{2}] operator grows at the speed of w^{2}+2 on the FGH.
...
a [{n+1}] b = a [{n}] a [{n}] a [{n}] a [{n}]......[{n}] a  a [{n}]'ed to itself b times. The [{n}] operator grows at the speed of w^{2}+n on the FGH.
So in a nut shell, the [{n}] operator is n levels of recursions past the [{0}] operator which dictates the number of {} pairs, which is essentially the fourth entry in a four entry array which has the same power as the length of a Conway chain.  So where does that put us on array notaion   only to {a,b,n,1,2}  the "d" component hasn't even budged. Another way to put it, {a,b,c,1,2} grows as fast as Ackermann style recursion on the length of Conway chains.
Lets up the stakes (BEAF steaks that is), continuing with extended operator notation:
a [{{0}}] b = a [{b}] a  the [{{0}}] operator grows at the speed of w^{2}+w on the FGH (Fast Growing Hierarchy).
a [{{1}}] b = a [{{0}}] a [{{0}}] a [{{0}}] a [{{0}}]......[{{0}}] a  a [{{0}}]'ed to itself b times. This is equal to a [{a [{a [{a [{....[{a [{a [{a [{a}] a}] a}] a}]....}] a}] a}] a}] a  with b nestings of [{..}] brackets! The [{{1}}] operator grows at the speed of w^{2}+w+1 on the FGH.
a [{{2}}] b = a [{{1}}] a [{{1}}] a [{{1}}] a [{{1}}]......[{{1}}] a  a [{{1}}]'ed to itself b times. The [{{2}}] operator grows at the speed of w^{2}+w+2 on the FGH.
...
a [{{n+1}}] b = a [{{n}}] a [{{n}}] a [{{n}}] a [{{n}}]......[{{n}}] a  a [{{n}}]'ed to itself b times. The [{{n}}] operator grows at the speed of w^{2}+w+n on the FGH.
Now the recursion is nesting within the [{..}] brackets, and [{{n}}] is n levels of recursions past the [{{0}}] operator which is based on Ackermann style recursion on the [{0}] operator which parallels the fourth entry in a 4entry array. So NOW where are we on array notation?   only to {a,b,n,2,2}  the "d" component is only a TWO (Gesundheit!). Another way to put it, {a,b,c,2,2} grows as fast as Ackermann style recursion on top of Ackermann style recursion on the length of Conway chains. Faints  Hello, you OK!  Lightly slaps face a couple times  Come on dude, wake up!  Hello!  Wakes up groggy  Ah great, you're alive  we got a LONG way to go  Screams and then goes unconcious.
Lets continue:
a [{{{0}}}] b = a [{{b}}] a  the [{{{0}}}] operator grows at the speed of w^{2}+w2 on the FGH (Fast Growing Hierarchy).
a [{{{1}}}] b = a [{{{0}}}] a [{{{0}}}] a [{{{0}}}] a [{{{0}}}]......[{{{0}}}] a  a [{{{0}}}]'ed to itself b times. This is equal to a [{{a [{{a [{{a [{{....[{{a [{{a [{{a [{{a}}] a}}] a}}] a}}]....}}] a}}] a}}] a}}] a  with b nestings of [{{..}}] brackets! The [{{{1}}}] operator grows at the speed of w^{2}+w2+1 on the FGH.
a [{{{2}}}] b = a [{{{1}}}] a [{{{1}}}] a [{{{1}}}] a [{{{1}}}]......[{{{1}}}] a  a [{{{1}}}]'ed to itself b times. The [{{{2}}}] operator grows at the speed of w^{2}+w2+2 on the FGH.
...
a [{{{n+1}}}] b = a [{{{n}}}] a [{{{n}}}] a [{{{n}}}] a [{{{n}}}]......[{{{n}}}] a  a [{{{n}}}]'ed to itself b times. The [{{{n}}}] operator grows at the speed of w^{2}+w2+n on the FGH.
Now the recursion is nesting within the [{{..}}] brackets, and [{{{n}}}] is n levels of recursions past the [{{{0}}}] operator which is based on Ackermann style recursion on the [{{0}}] operator! This gets us to {a,b,n,3,2}  the "d" component is now a three. Another way to put it, {a,b,c,3,2} grows as fast as Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on the length of Conway chains, this is three tiers of Ackermann style recursion on the length of Conway chains. Screams while still unconcious.
OK, time to go BOOYAH on this thing!:
a [{{...{{0}}...}}] b (with k+1 {} pairs) = a [{...{{b}}...}] a (with k {} pairs)  the [{{...{{0}}...}}] operator grows at the speed of w^{2}+wk on the FGH (Fast Growing Hierarchy).
a [{{...{{1}}...}}] b = a [{{...{{0}}...}}] a [{{...{{0}}...}}] a [{{...{{0}}...}}] a [{{...{{0}}...}}]......[{{...{{0}}...}}] a  a [{{...{{0}}...}}]'ed to itself b times. This is equal to a [{...{{a [{...{{a [{...{{a [{...{{::::::::[{...{{a [{...{{a [{...{{a [{...{{a}}...}] a}}...}] a}}...}] a}}...}]::::::::}}...}] a}}...}] a}}...}] a}}...}] a  with b nestings of [{{...{{}}...}}] brackets! The [{{...{{1}}...}}] operator grows at the speed of w^{2}+wk+1 on the FGH.
a [{{...{{2}}...}}] b = a [{{...{{1}}...}}] a [{{...{{1}}...}}] a [{{...{{1}}...}}] a [{{...{{1}}...}}]......[{{...{{1}}...}}] a  a [{{...{{1}}...}}]'ed to itself b times. The [{{...{{2}}...}}] operator grows at the speed of w^{2}+wk+2 on the FGH.
...
a [{{...{{n+1}}...}}] b = a [{{...{{n}}...}}] a [{{...{{n}}...}}] a [{{...{{n}}...}}] a [{{...{{n}}...}}]......[{{...{{n}}...}}] a  a [{{...{{n}}...}}]'ed to itself b times. The [{{...{{n}}...}}] operator grows at the speed of w^{2}+wk+n on the FGH.
Now the recursion is nesting within the [{...{{}}...}] brackets, and [{{...{{n}}...}}] is n levels of recursions past the [{{...{{0}}...}}] operator. This gets us to {a,b,n,k+1,2}  the "d" component is finally moving up. Get ready!! {a,b,c,d,2} grows as fast as Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of ............................... Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of Ackermann style recursion on top of the length of Conway chains, this is "d" tiers (or multiple tiers) of Ackermann style recursion on the length of Conway chains. Uh oh, I think he's dead!  and he's still screaming!!!. We can call this multiple tiered Ackerman style recursion "tetrentrical style recursion", for it is the same level of recursions necessary to get from a^b to {a,b,c,d}. To get from {a,b,c,d} to {a,b,c,d,2} it also takes tetrentrical style recursion on position three in the array ('a' is at position 0, 'b' at position 1, etc.)
Here are some numbers in this range:
Triggol = {10,10,10,100,2} = 10 [{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}] 10 with 100 {} pairs.
Triggolplex = {10,10,10,triggol,2} = 10 [{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}] 10 with triggol {} pairs.
Triggolduplex = {10,10,10,triggolplex,2} = 10 [{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}] 10 with triggolplex {} pairs.
When d = 3, then rule 1 becomes {a,1,c,d,3} = a. Rule 2 in not needed, rule 3a becomes {a,b,1,1,3} = {a,a,a,{a,b1,1,1,3},2}. Rule 3b becomes {a,b,1,d,3} = {a,a,{a,b,c1,d,3},d1,3}. Rule 3c becomes {a,b,c,d,3} = {a,(a,b1,c,d,3},c1,d,3}. Lets examine rule 3a a bit closer:
{a,b,1,1,3} = {a,a,a,{a,b1,1,1,3},2} = a [{{{{{{......{{{{{{a}}}}}}......}}}}}}] a  where there are {a,b1,1,1,3} pairs of {} within the [].
Solving it completely leads to the following  where each level after the first has 'number on previous level' pairs of {} within the []:
a

a [{{{{......{{{{{a}}}}}......}}}}] a

a [{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}] a

a [{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}] a
:
:
:
go all the way to the b'th level!!!
:

a [{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{......{{{{{a}}}}}......}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}] a
Wakes up from the dead to scream some more!  AAAAHHHHHH!!!!
We can even define the above as a [[{1}]] b in extended operator notation.
a [[{0}]] b = a [{{{{....{{{{a}}}}....}}}}] a  with b {}  the [[{0}]] operator grows at the speed of w^{2}2 on the FGH.
a [[{1}]] b = a [[{0}]] a [[{0}]] a [[{0}]] a [[{0}]]......[[{0}]] a  a [[{0}]]'ed to itself b times. The [[{1}]] operator grows at the speed of w^{2}2+1 on the FGH.
a [[{2}]] b = a [[{1}]] a [[{1}]] a [[{1}]] a [[{1}]]......[[{1}]] a  a [[{1}]]'ed to itself b times. The [[{2}]] operator grows at the speed of w^{2}2+2 on the FGH.
...
a [[{n+1}]] b = a [[{n}]] a [[{n}]] a [[{n}]] a [[{n}]]......[[{n}]] a  a [[{n}]]'ed to itself b times. The [[{n}]] operator grows at the speed of w^{2}2+n on the FGH.
The [[{n}]] operator is n levels of recursions past the [[{0}]] operator which dictates the number of {} pairs within two pairs of [] brackets. This takes us to {a,b,n,1,3}.
Continuing on:
a [[{{0}}]] b = a [[{b}]] a  the [[{{0}}]] operator grows at the speed of w^{2}2+w on the FGH.
a [[{{1}}]] b = a [[{{0}}]] a [[{{0}}]] a [[{{0}}]] a [[{{0}}]]......[[{{0}}]] a  a [[{{0}}]]'ed to itself b times. This is equal to a [[{a [[{a [[{a [[{....[[{a [[{a [[{a [[{a}]] a}]] a}]] a}]]....}]] a}]] a}]] a}]] a  with b nestings of [[{..}]] brackets! The [[{{1}}]] operator grows at the speed of w^{2}2+w+1 on the FGH.
a [[{{2}}]] b = a [[{{1}}]] a [[{{1}}]] a [[{{1}}]] a [[{{1}}]]......[[{{1}}]] a  a [[{{1}}]]'ed to itself b times. The [[{{2}}]] operator grows at the speed of w^{2}2+w+2 on the FGH.
...
a [[{{n+1}}]] b = a [[{{n}}]] a [[{{n}}]] a [[{{n}}]] a [[{{n}}]]......[[{{n}}]] a  a [[{{n}}]]'ed to itself b times. The [[{{n}}]] operator grows at the speed of w^{2}2+w+n on the FGH.
The recursion is nesting within the [[{..}]] brackets, and [[{{n}}]] is n levels of recursions past the [[{{0}}]] operator which is based on Ackermann style recursion on the [[{0}]] operator which does tetrentrical style recursion on the fourth entry in a 4entry array. We've reached {a,b,n,2,3} on array notation.
Lets continue:
a [[{{{0}}}]] b = a [[{{b}}]] a  the [[{{{0}}}]] operator grows at the speed of w^{2}2+w2 on the FGH.
a [[{{{1}}}]] b = a [[{{{0}}}]] a [[{{{0}}}]] a [[{{{0}}}]] a [[{{{0}}}]]......[[{{{0}}}]] a  a [[{{{0}}}]]'ed to itself b times. This is equal to a [[{{a [[{{a [[{{a [[{{....[[{{a [[{{a [[{{a [[{{a}}]] a}}]] a}}]] a}}]]....}}]] a}}]] a}}]] a}}]] a  with b nestings of [[{{..}}]] brackets! The [[{{{1}}}]] operator grows at the speed of w^{2}2+w2+1 on the FGH.
a [[{{{2}}}]] b = a [[{{{1}}}]] a [[{{{1}}}]] a [[{{{1}}}]] a [[{{{1}}}]]......[[{{{1}}}]] a  a [[{{{1}}}]]'ed to itself b times. The [[{{{2}}}]] operator grows at the speed of w^{2}2+w2+2 on the FGH.
...
a [[{{{n+1}}}]] b = a [[{{{n}}}]] a [[{{{n}}}]] a [[{{{n}}}]] a [[{{{n}}}]]......[[{{{n}}}]] a  a [[{{{n}}}]]'ed to itself b times. The [[{{{n}}}]] operator grows at the speed of w^{2}2+w2+n on the FGH.
Now the recursion is nesting within the [[{{..}}]] brackets, and [[{{{n}}}]] is n levels of recursions past the [[{{{0}}}]] operator which is based on Ackermann style recursion on the [[{{0}}]] operator! This gets us to {a,b,n,3,3}.
OK, time for another BOOYAH!:
a [[{{...{{0}}...}}]] b (with k+1 {} pairs) = a [[{...{{b}}...}]] a (with k {} pairs)  the [[{{...{{0}}...}}]] operator grows at the speed of w^{2}2+wk on the FGH.
a [[{{...{{1}}...}}]] b = a [[{{...{{0}}...}}]] a [[{{...{{0}}...}}]] a [[{{...{{0}}...}}]] a [[{{...{{0}}...}}]]......[[{{...{{0}}...}}]] a  a [[{{...{{0}}...}}]]'ed to itself b times. This is equal to a [[{...{{a [[{...{{a [[{...{{a [[{...{{::::::::[[{...{{a [[{...{{a [[{...{{a [[{...{{a}}...}]] a}}...}]] a}}...}]] a}}...}]]::::::::}}...}]] a}}...}]] a}}...}]] a}}...}]] a  with b nestings of [[{{...{{}}...}}]] brackets! The [[{{...{{1}}...}}]] operator grows at the speed of w^{2}2+wk+1 on the FGH.
a [[{{...{{2}}...}}]] b = a [[{{...{{1}}...}}]] a [[{{...{{1}}...}}]] a [[{{...{{1}}...}}]] a [[{{...{{1}}...}}]]......[[{{...{{1}}...}}]] a  a [[{{...{{1}}...}}]]'ed to itself b times. The [[{{...{{2}}...}}]] operator grows at the speed of w^{2}2+wk+2 on the FGH.
...
a [[{{...{{n+1}}...}}]] b = a [[{{...{{n}}...}}]] a [[{{...{{n}}...}}]] a [[{{...{{n}}...}}]] a [[{{...{{n}}...}}]]......[[{{...{{n}}...}}]] a  a [[{{...{{n}}...}}]]'ed to itself b times. The [[{{...{{n}}...}}]] operator grows at the speed of w^{2}2+wk+n on the FGH.
Now the recursion is nesting within the [[{...{{}}...}]] brackets, and [[{{...{{n}}...}}]] is n levels of recursions past the [[{{...{{0}}...}}]] operator. This gets us to {a,b,n,k+1,3}. {a,b,c,d,3} grows as fast as tetrentrical style recursion on top of tetrentrical style recursion on the length of a Conway chain. Tetrentrical style recursions go from a^b to {a,b,c,d} to {a,b,c,d,2} to {a,b,c,d,3}.
Here are some numbers in this range:
Pentatri = {3,3,3,3,3} = 3 [[{{{3}}}]] 3
Traggol = {10,10,10,100,3} = 10 [[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]] 10 with 100 {} pairs.
Traggolplex = {10,10,10,traggol,3} = 10 [[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]] 10 with traggol {} pairs.
Traggolduplex = {10,10,10,traggolplex,3} = 10 [[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]] 10 with traggolplex {} pairs.
Lets look at Pentatri = {3,3,3,3,3} = {3,{3,2,3,3,3},2,3,3}
= {3,{3,{3,1,3,3,3},2,3,3},2,3,3} = {3,{3,3,2,3,3},2,3,3}
= {3,{3,{3,3,1,3,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,2,1,3,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,3,{3,1,1,3,3},2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,3,3,2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,{3,{3,3,{3,3,3,1,3},1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,1,1,3},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,2,1,1,3},2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,3,3,{3,1,1,1,3},2},2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,3,3,3,2},2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{ 3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,3,3,3,1},1},1,1,2},2,1,2} ,1,2},1,2,2},2,2,2},2,2},1,3,2},2,3,2 },2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{ 3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{3,3,3,3}},1,1,2},2,1,2} ,1,2},1,2,2},2,2,2},2,2},1,3,2},2,3,2 },2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}
= {3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,{ 3,{3,{3,3,{3,{3,{3,3, {3,{3,{3,3,3,tetratri},1,1,2},2,1,2} ,1,2},1,2,2},2,2,2},2,2},1,3,2},2,3,2 },2},1,1,3},2,1,3} ,1,3},1,2,3},2,2,3},2,3},1,3,3},2,3,3}
Using the operator notation, Pentatri looks like this:
3 [[{{{3}}}]] 3 = 3 [[{{{2}}}]] 3 [[{{{2}}}]] 3
= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{{1}}}]] 3
= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{3}}]] 3 }}]] 3
= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{3}]] 3 }]] 3 }}]] 3
= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{2}]] 3 [[{1}]] 3 [[{1}]] 3 }]] 3 }}]] 3
= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{2}]] 3 [[{1}]] 3 [{{{........3[{{{3}}}]3......{{{{3}}}}.......3[{{{3}}}]3.........}}}] 3 }]] 3 }}]] 3
= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{2}]] 3 [[{1}]] 3 [{{{........3 [{{{2}}}] 3 [{{{1}}}] 3 [{{ 3 [{{2}}] 3 [{{1}}] 3 [{ 3 [{2}] 3 [{1}] 3 {{{........3{{{3}}}3......{{{{3}}}}.......3{{{3}}}3.........}}} 3 }] 3 }}] 3......{{{{3}}}}.......3 [{{{2}}}] 3 [{{{1}}}] 3 [{{ 3 [{{2}}] 3 [{{1}}] 3 [{ 3 [{2}] 3 [{1}] 3 {{{........3{{{3}}}3......{{{{3}}}}.......3{{{3}}}3.........}}} 3 }] 3 }}] 3.........}}}] 3 }]] 3 }}]] 3
= 3 [[{{{2}}}]] 3 [[{{{1}}}]] 3 [[{{ 3 [[{{2}}]] 3 [[{{1}}]] 3 [[{ 3 [[{2}]] 3 [[{1}]] 3 [{{{........3 [{{{2}}}] 3 [{{{1}}}] 3 [{{ 3 [{{2}}] 3 [{{1}}] 3 [{ 3 [{2}] 3 [{1}] 3 {{{........Tetratri......{{{{3}}}}.......Tetratri.........}}} 3 }] 3 }}] 3......{{{{3}}}}.......3 [{{{2}}}] 3 [{{{1}}}] 3 [{{ 3 [{{2}}] 3 [{{1}}] 3 [{ 3 [{2}] 3 [{1}] 3 {{{........Tetratri......{{{{3}}}}.......Tetratri.........}}} 3 }] 3 }}] 3.........}}}] 3 }]] 3 }}]] 3
Continuing onwards, {a,b,c,d,4} = a [[[{{{{{{....d....{{{{c}}}}....d....}}}}}}]]] b  this is tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on the fourth entry in a 4entry array!
{a,b,c,d,5} = a [[[[{{{{{{....d....{{{{c}}}}....d....}}}}}}]]]] b  this is tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on the fourth entry in a 4entry array!
{a,b,c,d,6} = a [[[[[{{{{{{....d....{{{{c}}}}....d....}}}}}}]]]]] b  this is tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on the fourth entry in a 4entry array!
...
{a,b,c,d,e} = a [[[[[[....e....[[[[[{{{{{{....d....{{{{c}}}}....d....}}}}}}]]]]]....e....]]]]]] b  this is tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of ...............................tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on top of tetrentrical style recursion on the fourth entry in a 4entry array! Still dead, running around screaming, catches fire, turns into a skeleton, running everywhere screaming  brain EXPLODES!! taking out a 5000 light year radius!
We can call this repeated tetrentrical recursion  pententrical recursion.
Time to continue:
a [[..[[{0}]]..]] b (with k [] pairs) = a [[..[{{{{....{{{{a}}}}....}}}}]..]] a (with k1 [] pairs)  with b {}  the [[..[[{0}]]..]] operator grows at the speed of w^{2}k on the FGH.
a [[..[[{1}]]..]] b = a [[..[[{0}]]..]] a [[..[[{0}]]..]] a [[..[[{0}]]..]] a [[..[[{0}]]..]]......[[..[[{0}]]..]] a  a [[..[[{0}]]..]]'ed to itself b times. The [[..[[{1}]]..]] operator grows at the speed of w^{2}k+1 on the FGH.
a [[..[[{2}]]..]] b = a [[..[[{1}]]..]] a [[..[[{1}]]..]] a [[..[[{1}]]..]] a [[..[[{1}]]..]]......[[..[[{1}]]..]] a  a [[..[[{1}]]..]]'ed to itself b times. The [[..[[{2}]]..]] operator grows at the speed of w^{2}k+2 on the FGH.
...
a [[..[[{n+1}]]..]] b = a [[..[[{n}]]..]] a [[..[[{n}]]..]] a [[..[[{n}]]..]] a [[..[[{n}]]..]]......[[..[[{n}]]..]] a  a [[..[[{n}]]..]]'ed to itself b times. The [[..[[{n}]]..]] operator grows at the speed of w^{2}k+n on the FGH.
The [[..[[{n}]]..]] operator is n levels of recursions past the [[..[[{0}]]..]] operator which dictates the number of {} pairs within k pairs of [] brackets. This takes us to {a,b,n,1,k+1}.
Continuing on:
a [[..[[{{0}}]]..]] b (with k [] pairs) = a [[..[[{b}]]..]] a (with k [] pairs)  the [[..[[{{0}}]]..]] operator grows at the speed of w^{2}k+w on the FGH.
a [[..[[{{1}}]]..]] b = a [[..[[{{0}}]]..]] a [[..[[{{0}}]]..]] a [[..[[{{0}}]]..]] a [[..[[{{0}}]]..]]......[[..[[{{0}}]]..]] a  a [[..[[{{0}}]]..]]'ed to itself b times. The [[..[[{{1}}]]..]] operator grows at the speed of w^{2}k+w+1 on the FGH.
a [[..[[{{2}}]]..]] b = a [[..[[{{1}}]]..]] a [[..[[{{1}}]]..]] a [[..[[{{1}}]]..]] a [[..[[{{1}}]]..]]......[[..[[{{1}}]]..]] a  a [[..[[{{1}}]]..]]'ed to itself b times. The [[..[[{{2}}]]..]] operator grows at the speed of w^{2}k+w+2 on the FGH.
...
a [[..[[{{n+1}}]]..]] b = a [[..[[{{n}}]]..]] a [[..[[{{n}}]]..]] a [[..[[{{n}}]]..]] a [[..[[{{n}}]]..]]......[[..[[{{n}}]]..]] a  a [[..[[{{n}}]]..]]'ed to itself b times. The [[..[[{{n}}]]..]] operator grows at the speed of w^{2}k+w+n on the FGH.
The [[..[[{{n}}]]..]] operator is n levels of recursions past the [[..[[{{0}}]]..]] operator which is based on Ackermann style recursion on the [[..[[{0}]]..]] operator which does tetrentrical style recursion over and over again on the fourth entry in a 4entry array. We've reached {a,b,n,2,k+1} on array notation.
OK, time for the grand slam BOOYAH!:
a [[..[[{{...{{0}}...}}]]..]] b (with k+1 {} pairs and j [] pairs) = a [[..[[{...{{b}}...}]]..]] a (with k {} pairs and j [] pairs)  the [[..[[{{...{{0}}...}}]]..]] operator grows at the speed of w^{2}j+wk on the FGH.
a [[..[[{{...{{1}}...}}]]..]] b = a [[..[[{{...{{0}}...}}]]..]] a [[..[[{{...{{0}}...}}]]..]] a [[..[[{{...{{0}}...}}]]..]] a [[..[[{{...{{0}}...}}]]..]]......[[..[[{{...{{0}}...}}]]..]] a  a [[..[[{{...{{0}}...}}]]..]]'ed to itself b times. The [[..[[{{...{{1}}...}}]]..]] operator grows at the speed of w^{2}j+wk+1 on the FGH.
a [[..[[{{...{{2}}...}}]]..]] b = a [[..[[{{...{{1}}...}}]]..]] a [[..[[{{...{{1}}...}}]]..]] a [[..[[{{...{{1}}...}}]]..]] a [[..[[{{...{{1}}...}}]]..]]......[[..[[{{...{{1}}...}}]]..]] a  a [[..[[{{...{{1}}...}}]]..]]'ed to itself b times. The [[..[[{{...{{2}}...}}]]..]] operator grows at the speed of w^{2}j+wk+2 on the FGH.
...
a [[..[[{{...{{n+1}}...}}]]..]] b = a [[..[[{{...{{n}}...}}]]..]] a [[..[[{{...{{n}}...}}]]..]] a [[..[[{{...{{n}}...}}]]..]] a [[..[[{{...{{n}}...}}]]..]]......[[..[[{{...{{n}}...}}]]..]] a  a [[..[[{{...{{n}}...}}]]..]]'ed to itself b times. The [[..[[{{...{{n}}...}}]]..]] operator grows at the speed of w^{2}j+wk+n on the FGH.
[[..[[{{...{{n}}...}}]]..]] is n levels of recursions past the [[..[[{{...{{0}}...}}]]..]] operator. This gets us to {a,b,n,k+1,j}.
Here are some numbers in this range:
Treegol = {10,10,10,100,4} = 10 [[[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]]] 10 with 100 {} pairs.
Superpent = {5,5,5,5,5} = 5 [[[[{{{{{5}}}}}]]]] 5
Trigol = {10,10,10,100,5} = 10 [[[[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]]]] 10 with 100 {} pairs.
Troggol = {10,10,10,100,6} = 10 [[[[[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]]]]] 10 with 100 {} pairs.
Tragol = {10,10,10,100,7} = 10 [[[[[[{{{{{{{{{{......{{{{{10}}}}}......}}}}}}}}}}]]]]]] 10 with 100 {} pairs.
Pentadecal = {10,10,10,10,10} = 10 [[[[[[[[[{{{{{{{{{{10}}}}}}}}}}]]]]]]]]] 10
Quadroogol = {10,10,10,10,100} =
10 [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[{{{{{{{{{{10}}}}}}}}}}]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] 10 with 99 pairs of [].
Pentadecalplex = {10,10,10,10,pentadecal} = 10 [[[[[.....pentadecal1.....[[[[{{{{{{{{{{10}}}}}}}}}}]]]]].....pentadecal1.....]]]] 10
Quadroogolplex = {10,10,10,10,quadroogol} = 10 [[[[[.....quadroogol1.....[[[[{{{{{{{{{{10}}}}}}}}}}]]]]].....quadroogol1.....]]]] 10
Quadroogolduplex = {10,10,10,10,quadroogolplex} = 10 [[[[[.....quadroogolplex1.....[[[[{{{{{{{{{{10}}}}}}}}}}]]]]].....quadroogolplex1.....]]]] 10
At its fullest extent, pententrical arrays grow at the speed of w^{3} on the FGH. Coming up next are the rest of linear arrays, which generates numbers that blow the pententrical ones out of the water.