**Pound-Star Notation** is an in-progress notation by SuperJedi224.^{[1]} 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

- Start with n=1.
- If the final separator group is anything other than a single *:
- If the final item in the group is a supernest:
- If it is empty, put the current value of n in it
- If it contains the number 0, replace it with an at sign
- If it contains any other number, decrement the number by one and wrap the supernest in n layers of nesting groups
- If it contains a separator group:
- If the last item in the supernest is a star character, remove it and wrap the supernest in n layers of nesting groups
- Otherwise, reduce it as you would a normal separator group

- If the final item in the group is any nesting group, replace it with n concatenated copies of whatever subgroup it contains
- 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.
- If the final item in the group is an explodon array:
- If there are two or more terms, of which the last is 0, remove the last term.
- Else, if the first term is 0:
- If that is the only term, replace that explodon array with a carat.
- Else, decrement the first nonzero term by one and set all earlier terms to n.

- Else, replace that explodon array with n identical explodon arrays that have had the first term decremented by 1.

- If the final character in the group is a carat, replace it with n stars.
- 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.

- If the final item in the group is a supernest:
- Else:
- If the last entry is a number, multiply n by this number, then remove it from the expression.
- If the last entry is a pound sign, replace it with the current n.
- If the last entry is a proto-set ((x)), replace it with a set of n elements each equalling x.
- If the last entry is a set:
- If the set contains only one element, replace the set with that number raised to the power of the current n.
- Else, if the final element is 0, remove it and increment n by 1.
- Else, decrement the final element by 1 and increment the element preceding it by n.

- Repeat rules 2-3 until the expression is reduced to a single number. This is the value of the expression.

## Growth Rate

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

## Low-level example

#*(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**