Pound-Star Notation is an in-progress notation by SuperJedi224. The latest revision of the notation, Multi-Nested Hyper-Exploding Pound-Star (H#*<<>>), is defined as follows:

An expression consists of one or more entries separated by groups consisting of one or more items, each of which may be either a star character (*), a carat (^), an explodon array, denoted as a colon-separated list of nonnegative integers, of which at least one must be positive, wrapped in curly brackets; an at sign (@), a nested group (denoted as any valid separator group- even one containing other nesting groups or supernests- wrapped in angle brackets), or a supernest, denoted as either a nonnegative integer or any valid separator group in square brackets or an empty pair of square brackets. The first entry must be a pound sign (#). Subsequent entries my be either a pound sign, a single positive integer, an ordered, comma-separated, set of one or more nonnegative integers, of which at least one must be positive, wrapped in a single set of parentheses; or a "proto-set" denoted as a single positive integer wrapped in two pairs of parentheses.

For instance, one valid expression is #[@]{0:3}((2)){2}(1,3){2}2**#*7.

## Rules

2. If the final separator group is anything other than a single *:
1. If the final item in the group is a supernest:
1. If it is empty, put the current value of n in it
2. If it contains the number 0, replace it with an at sign
3. If it contains any other number, decrement the number by one and wrap the supernest in n layers of nesting groups
4. If it contains a separator group:
1. If the last item in the supernest is a star character, remove it and wrap the supernest in n layers of nesting groups
2. Otherwise, reduce it as you would a normal separator group
2. If the final item in the group is any nesting group, replace it with n concatenated copies of whatever subgroup it contains
3. If the final item in the group is an at sign, replace it with an explodon array of n terms, of which the last term is 1 and all preceding terms are 0.
4. If the final item in the group is an explodon array:
1. If there are two or more terms, of which the last is 0, remove the last term.
2. Else, if the first term is 0:
1. If that is the only term, replace that explodon array with a carat.
2. Else, decrement the first nonzero term by one and set all earlier terms to n.
3. Else, replace that explodon array with n identical explodon arrays that have had the first term decremented by 1.
5. If the final character in the group is a carat, replace it with n stars.
6. If the final character in the group is a star, replace the final entry with a series of n identical entries whose separator groups have had the final star removed.
3. Else:
1. If the last entry is a number, multiply n by this number, then remove it from the expression.
2. If the last entry is a pound sign, replace it with the current n.
3. If the last entry is a proto-set ((x)), replace it with a set of n elements each equalling x.
4. If the last entry is a set:
1. If the set contains only one element, replace the set with that number raised to the power of the current n.
2. Else, if the final element is 0, remove it and increment n by 1.
3. Else, decrement the final element by 1 and increment the element preceding it by n.
4. Repeat rules 2-3 until the expression is reduced to a single number. This is the value of the expression.

## Basic rules

n=a, #....*b  => n=(a*b) , #....

n=a , #....*(...,0) => n=a+1 , #....*(...)

n=a , #....*(...b,c) (b>=0,c>0) => n=a , #....*(...b+a,c-1)

n=a , #....*(b) => #*$$a^{b}$$

n=a , # => the expression value equal to a

## Growth Rate

The latest extension has a limit ordinal of about $$\varepsilon_0$$ in the fast-growing hierarchy.

#*(1,0,1)*2

n=1, #*(1,0,1)*2

n=2, #*(1,0,1)

n=2, #*(1,2,0)

n=3, #*(1,2)

n=3, #*(4,1)

n=3, #*(7,0)

n=4, #*(7)

n=4, #*2,401

n=9,604, #

9,604