4est

4est is a tree based esolang by User:BoundedBeans featuring nested tree data structures. This was the first esolang he created, so it is quite bad.

Storage

The way it stores data is in a variety of places: One or more outer trees, each node containing an inner tree. The inner trees are confusingly referred to as forests (NOT the outer trees), while individual VALUES in the inner tree are referred to as trees. There can be multiple outer trees, known as continents, stored in an ArrayList. There can be multiple ArrayLists, known as realities, stored in YET ANOTHER tree structure, because everybody knows that all the realities of the multiverse are folded together into a GIANT PRIMORDIAL PLUM TREE.

The individual values of an inner tree are 32-bit floating point numbers represented as an integer (optionally with a hyphen at the start for negative) with the comma as the decimal point (This language avoids the period for anything other than the end of the statement, at least after preprocessing, to allow a simple split function to separate statements).

Instructions

Instructions are separated by a period followed by a tab, a space, or a newline. All other whitespace is ignored. “//“ can be used to comment out things until a newline.

Basic operations

Visit the [list of ordinal numbers] forest. Create the outer tree structure corresponding to the node numbers of each level, every node with a smaller number, and the parents of each level and the smaller parent numbers. If a tree already exists, add to the bottom level. Be careful with this command, because this can get big really fast. Sets them all to a tree containing only a root node. For example: Visit the 4th 2nd 5th forest. Creates a tree with a root node having 4 children, each having 2 children, each having 5 children. This creates a total of (4*2*5)+(4*2)+(4)+1 = 53 nodes.

Propagate the [list of ordinal numbers] forest (number) times. Adds number children to the coordinates in the outer tree.

Visit the [list of ordinal numbers] tree. Create an inner tree in a similar manner to the Visit Forest command, but nested inside the outer tree and with all values set to 0.

Propagate the [list of ordinal numbers] tree (number) times. Adds number children to the coordinates in the inner tree.

Fly over the [list of ordinal numbers] forest. Moves the pointer to the coordinates of the ordinals in the outer tree.

Fly over the [list of ordinal numbers] tree. Moves the pointer to the coordinates of the ordinals in the inner tree.

Axe the forest. Add one to the outer pointer.

Cut the forest. Subtract one from the outer pointer.

Mine the forest. Move the pointer to the parents in the outer tree.

Chop the (ordinal) forest. Move the pointer to the ordinal child in the outer tree.

[Any one of the above four commands but with "tree" instead of "forest"] Do the same thing for the inner pointer.

Graft the tree [number] times. Set the value at the current pointer positions to number.

Graft the [list of ordinals 1] tree in the [list 2] forest to the [list 3] tree in the [list 4] forest. Sets the value at outer coordinates in list 3 and inner coordinates list 4 to the value of the coordinates of list 1 and 2.

Plant the [list of ordinal numbers] sapling around the [list 2] tree. Add the number at coordinates list 1 to coordinates list 2. (inner tree)

Destroy the [list of ordinal numbers] sapling around the [list 2] tree. Subtract the number at coordinates list 1 from coordinates list 2. (inner tree)

Spray the [list of ordinal numbers] sapling around the [list 2] tree. Multiply the number at coordinates list 1 by coordinates list 2 and store the result in coordinates list 2. (inner tree)

Decimate the [list of ordinal numbers] sapling around the [list 2] tree. Divide the number at coordinates list 1 by coordinates list 2 and store the result in coordinates list 2. (inner tree)

Loops and if-else

All loops and if-else start statements act as if they include the opening bracket within.

Prune the [list 1 of ordinals] tree in the [list 2] forest. Do the coordinates as usual, and start a loop. Each iteration, the number at those coordinates will be decremented by one. At the start of each iteration, check if it equals zero, and if it does, stop the loop.

While the [list 1 of ordinals] tree in the [list 2] forest is (conditional) the [list 3] tree in the [list 4] forest. Continue the loop as long as a conditional is true between the two values.

If the [list 1 of ordinals] tree in the [list 2] forest is (conditional) the [list 3] tree in the [list 4] forest. Like a while loop, but only goes once if true, does not go if false. An if statement is equivalent to this.

Or else. Else. Else if can be accomplished by putting an if statement inside of an else statement.

Sterilize tools. Closing brackets.

Conditionals

= as strong as
!= incomparable to
< less well-rooted than
> more well-rooted than
<= containing less fruit than
>= containing more fruit than

Input/output

Take recommendations. Input a number into the value at the current pointer positions.

Take advice. Input the ascii/unicode value of a character.

Give recommendations. Output the value at the current pointer positions as a number.

Give advice. Output the value at the current pointer positions as a character.

Ask for help. Loop until there is no more input.

For these, a file path can also be specified by using "at", "to", or "from" followed by "PATH:" then the full file path, or the better "REL:" followed by the path of a file in the same folder, without the path leading to the folder.

Tree structure manipulation

This takes the form of "Birdwatch" commands for the outer tree, and "Fishwatch" for the inner tree.

Birdwatch finch./Fishwatch carp. Duplicates the lowest level of the tree (if inner tree, specified by the pointer), with every parent having one child completely copied. Doing this on the outer tree will copy all inner trees and their values on the lowest level, while doing this on the inner tree copies the value. Useful for duplicating large sequences of values.

Birdwatch hawk. Only for outer trees. Duplicates the structure of the inner trees, but not the values inside.

Birdwatch cardinal. Only for outer trees. Puts the entire structure of the outer trees into the inner tree at the outer pointer, but sets all the values to 0. WARNING: This deletes all existing values in the inner tree.

Reality manipulation

Enter new continent. Creates a new outer tree and assigns it an index based on when you added it. Does not switch list pointer to the outer tree. Starts with only a root node with a tree with only a root node assigned to 0 inside.

Sail west (number) hours. Enters the outer tree with number index. Now, any operations will apply to this outer tree, not the previous one. You can use a single compound ordinal without th instead of the number.

Grab possessions before traveling. Assign the carryover integer to the value at the current outer and inner pointers.

Rest. Put the carryover integer into the value at the current outer and inner pointers in the new tree.

Nuke continent (number). Removes the outer tree with number index. Pushes everything past one level back. You can use a single compound ordinal without the final th instead of the number.

Explore for (number) hours. Adds a continents at the specified index, pushing everything else forward. Not allowed if there are no continents past it since it would just be empty space and the programming language would throw an error. You can use a single compound ordinal without the final th instead of the number.

Primordial manipulation

All take the form of "Plumcommand", then the command, then any arguments. The plum tree is primordial and therefore only sees the basic rules which govern all realities; it will not understand your verbose English statements.

Plumcommand pointerparent. Moves primordial pointer to the parent.

Plumcommand pointerchild (number). Move primordial pointer to the numberth child. You can use a single compound ordinal without the final th instead of the number.

Plumcommand pointersibling (number). Move primordial pointer number siblings to the right. Negative numbers will move it to the left. You can use a single compound ordinal without the final th instead of the number.

Plumcommand createchild (number). Create number child nodes to the current pointer. If it already has children, it will just make number more children. You can use a single compound ordinal without the final th instead of the number.

Plumcommand ambassadorget (x) (y) (z). Take the number at the current pointers and put it in the dimensional array in the indexes specified. The indexes can only be from 0-3, inclusive, meaning there can be a maximum of 64 ambassador values. You can use a single compound ordinal without the final th instead of x, y, or z.

Plumcommand ambassadorput (x) (y) (z). Take the number from the dimensional array at the index and put it as the value at the current pointers. You can use a single compound ordinal without the final th instead of x, y, or z.

Special ordinals

While normal ordinals are great for specifying coordinates, they lack the ability to do it dynamically (using a variable as the coordinate). Using parenthesis, we can do things like this (known as compound ordinals):

(1st 5th 7th)th

This uses the value in the coordinates 1 5 7 in the inner tree at the current outer pointer.

(<6th 2nd 8th> 2nd 9th)th

This goes to the coordinates 6 2 8 in the outer tree, uses that inner tree, then the coordinates 2 9 in that inner tree, and uses it as the value for the ordinal.

And yes, nested parenthesis work too.

(<(<8th 2nd> 7th 4th)th 2nd> 6th 4th (<2nd 3rd> 2nd 7th)th)th

Uses the coordinate 8 2 in the outer tree, then the 7 4 coordinates in the inner tree, uses the value in there as the first coordinate, along with 2, then the inner tree at that coordinate is used, which the coordinates 6 4 are used, then the third coordinate is the value of coordinates 2 3 in the outer tree, and the coordinates 2 7 in the corresponding inner tree.

This is quite complicated, but it can be used with as many levels of parenthesis as you desire.

We can also specify the root node by using mother. As in Fly over the mother forest. Mother is special because it can't be used with any other ordinals on the same level. The root node in the outer tree can still have ordinals in the inner tree. Coordinates in the outer tree can still have accessible root nodes in the inner tree. For example:

Graft the 7th 9th 15th tree in the mother forest to the mother tree in the 3rd 5th forest.

As of Specification 2.0, current can be used as the ordinal of the owner of a method. Note that this only retrieves the inner or outer tree coordinates, depending on the context. You can also either add a sequence of parent to it, or an ordinal list to get the children.

Specification 2.0

Specification 2.0 adds a few new features.

Graft Sources

The Graft the tree x times. can now have x start with a greater than sign (>), followed by a string of plain-text, containing no greater than symbols or whitespace, followed by another greater-than sign, followed by a string of ?-escaped text, followed by another greater than sign, followed by another string of ?-escaped text. In ?-escaped text, ? gets followed by two hexadecimal digits (letters uppercase), and means the byte with that hexadecimal representation. Greater than symbols, question marks, and whitespace must be escaped this way.

• The plain text represents the "source", which gives the first escaped text meaning.
• The first escaped text determines along with the source what should be put into the cell (which doesn't necessarily have to be a number).
• The second text will be unescaped and substituted in for x in the graft command if either there is an error with the parsing or assignment or the source is not supported. It can be another greater than construct (containing another level of second text), or just a regular number.

Sources starting with a caret (^) are reserved for built-in sources.

Here is a table of sources:

Source name	Source contents description (before escape)	Action	Examples
^Copy	Four fields, separated by slashes A path of numerical indexes of children in the primordial tree, separated by periods, or "root". A numerical index in the list of continents (0-based). A path of numerical indexes of children in the outer tree, separated by periods, or "root". A path of numerical indexes of children in the inner tree, separated by periods, or "root". A number may be replaced with another path in square brackets, or a ^Math expression in matched parenthesis. Alternatively to all of this, "self" can be used for the owner of the current method, and "here" can be used for the current cell.	Copies the value of the cell specified by the path. If the cell cannot be found, the second text will be tried.	//Gets the cell you start on, or -1. Graft the tree >^Copy>root/0/root/root>-1 times. //Gets the 5th 3rd tree in the mother forest in the 1st continent in the 2nd 4th 7th realm, or 8. Graft the tree >^Copy>2.4.7/1/root/5.3>8 times. //Gets the mother tree in the 4th (<3rd> 5th 2nd)th forest in the default realm, or 5.16. Graft the tree >^Copy>root/0/4.[root/0/3/5.2]/root>5.16 times.
^Math	An expression in reverse polish notation (elements separated by spaces) containing possible arguments to the graft command (with sources required to have a numerical result or a string result representing a number or a graft source which meets the conditions specified in this pair of parenthesis [recursive]), as well as the operators OP+ (addition), OP- (subtraction), OP* (multiplication), OP/ (division), OP^ exponentiation, OPRoot (rightth root of left, positive result only, OP-Root for negative root), and OPLog (logarithm of left element with right as the base).	Evaluates the math expression with only positive square roots. If a graft source element fails, a graft source element results in a non-numerical result, you divide by zero, do an impossible logarithm, there are no or multiple solutions, or the one solution is not real, the second text will be tried.	//Adds 6 to the contents of the 5th tree in the mother forest, or 128. Graft the tree >^Math>6?20?3E^Copy?3Eroot/0/root/5?3E0?20OP+>-128 times. //Booleanizes the default cell by dividing 1 by it (if it's zero, a division by zero will occur and it will do the second text). Graft the tree >^Math>1?20?3E^Copy?3Eroot/0/root/root?3E0?20OP/?200?20OP*?201?20OP+>0 times. //Works as a NOT gate on the default cell. Graft the tree >^Math>1?20?3E^Copy?3Eroot/0/root/root?3E0?20OP/?200?20OP*?200?20OP+>1 times. //Works as an AND gate on the first two children of the default cell. Graft the tree >^Math>1?20?3E^Copy?3Eroot/0/root/1?3E0?20?3E^Copy?3Eroot/0/root/2?3E0?20OP*?20OP/?200?20OP*?201?20OP+>0 times. //Works as an OR gate on the first two children of the default cell (notice the plus here v). Graft the tree >^Math>1?20?3E^Copy?3Eroot/0/root/1?3E0?20?3E^Copy?3Eroot/0/root/2?3E0?20OP+?20OP/?200?20OP*?201?20OP+>0 times.
^String	Any text.	Gets a string.	//Gets the string "Hello, World!". Graft the tree >^String>Hello,?20World!>0 times.
^Concat	Multiple strings of the same format as ^Copy, separated by ampersands (&).	Returns the concatenation of the strings and numbers pointed to.	//Concatenates the two children of the default cell, or the empty string, or -1. Graft the tree >^Concat>root/0/root/1&root/0/root/2>?3E^String?3E?3E-1
^Substring	Three strings of the same format as ^Copy, separated by ampersands.	Takes the first address, takes the substring of that cell with length of the value at the third address starting at the value at the second address.
^Equals	Multiple strings of the same format as ^Copy, separated by ampersands.	Checks if all of the strings are equal, returns 1 if yes, 0 if no.
^Length	The same format as ^Copy.	Gets the length of the string.
^Eval	The same format as ^Copy.	Evaluates the string as a graft source, returns the result.
^Class	A JSON object mapping string names to strings of 4est code.	Creates a class with those methods. Inside the methods, self is available in ^Copy syntax and in other places imitating it, and current is available in ordinal syntax. Also, the command "Travel to the current tree." will jump to the object's position, including the realm and continent. Method names must not contain periods or whitespace. The methods will go through preprocessing at the time the class is created and the results will be saved permanently for the class.	//Makes a class of numbers which are incrementable by calling the Increment method. Graft the tree >^Class>{"Increment":"Plant?20the?20current?20sapling?20around?20the?20current?20tree."}>0 times.
^Object	Two strings of the same format as ^Copy, separated by an ampersand.	Takes the first address as a value, and the second as a class. Copies the value of the object, but adds the class to it. The value can be numbers, strings, classes, or another type of value specified by custom sources. This actually copies the class (or, equivalently since classes are immutable, just keeps a reference to it), so you can replace the class with something else and the methods will still work.	//Goes to path root/0/root/1 Fly over the 1st tree. //Makes a class of numbers which are incrementable by calling the Increment method. Graft the tree >^Class>{"Increment":"Plant?20the?20current?20sapling?20around?20the?20current?20tree."}>0 times. //Goes to path root/0/root/2 Fly over the 2nd tree. //Sets root/0/root/2 to 0. Graft the tree 0 times. //Makes root/0/root/2 into an object of the root/0/root/1 class. Graft the tree >^Object>here&root/0/root/1>0 times. //Runs the "Increment" method specified in the class. Apply Increment fertilizer to the 2nd tree in the mother forest.
^Preprocess	A string of the same form as ^Copy.	Preprocesses the pointed-to string, returns the result.	//Stores a string with a preprocessor directive in it. Graft the tree >^String>?3F_Pre[4estCall:Take?20advice?2E?20Plant?20the?20mother?20sapling?20around?20the?mother?tree?2E?20?Give?20advice?2E&A]>0 times. //After this, the cell will contain "B", since that's what the preprocessor would do with the above string. Graft the tree >^Preprocess>here>0 times.

The "Apply x fertilizer to the y tree in the z forest." statement

This runs method x of the object pointed to by y and z.

To run a method M on the owner of the current method, you can run:

Apply M fertilizer to the current tree in the current forest.

The "Converse with the plum tree." statement

This runs a system call with the string in the currently pointed cell.

The "Act on the dire state of the x tree in the y forest." statement

This takes the pointed to cell, which should be a string, and evals it as 4est code with the current environment in mind.

The preprocessor

The preprocessor activates when it encounters the following syntax:

?_Pre[directive name:text not containing a right square bracket]

Inside the square brackets, }| gets replaced by a right square bracket, and }# gets replaced by a right curly bracket. This means you can string hashtags after the curly bracket to encode }| or its escaped versions.

?_ does not cause problems for graft source escapes because those will always have one of the characters in 0123456789ABCDEF immediately following the question mark.

Here are the directives included in Specification 2.0. (If you would like to add a custom preprocessor directive, please have the name start with a plus sign (+)).

• NLEscape
  • The text inside has all occurences of ;;N\n, ;;R\r, and ;;RN\r\n removed.
• NLEscape->
  • Same as NLEscape, but the preprocessor runs after the strings are removed.
• NLEscape<-
  • Same as NLEscape, but the preprocessor runs before the strings are removed.
• NLEscape<->
  • Same as NLEscape, but the preprocessor runs before AND after the strings are removed.
• NLEscapeDelayStart, NLEscapeDelayStart->, NLEscapeDelayStart<-, NLEscapeDelayStart<->
  • Same as the corresponding NLEscape directive, ignores the first character, and doesn't start a line or a line continuation until the first occurence of that character (this is made to allow indenting line continuations, which normally get a space in them, which is a problem for graft sources). Similar arrow variants to NLEscape.
• System
  • Preprocesses the text, runs a shell system call with it, preprocesses the output, and inserts it into the code.
• 4estCall
  • The text should be two strings separated by an ampersand, with %% being replaced with an ampersand and %# being replaced with %. Preprocesses both strings, runs the first as 4est code with the second as input, gets the output, preprocesses it, inserts it into the code.
• SpaceSub
  • Removes _^, removes _**, replaces _/ with space, --. with _, and -= with -, then preprocesses the space. Similar arrow variants to NLEscape.

Programs

Hello world

Visit the 12th tree.
Fly over the 1st tree.
Graft the tree 72 times.
Fly over the 2nd tree.
Graft the tree 101 times.
Fly over the 3rd tree.
Graft the tree 108 times.
Graft the 3rd tree in the mother forest to the 4th tree in the mother forest.
Fly over the 5th tree.
Graft the tree 111 times.
Fly over the 6th tree.
Graft the tree 32 times.
Fly over the 7th tree.
Graft the tree 119 times.
Graft the 5th tree in the mother forest to the 8th tree in the mother forest.
Fly over the 9th tree.
Graft the tree 114 times.
Graft the 3rd tree in the mother forest to the 10th tree in the mother forest.
Fly over the 11th tree.
Graft the tree 100 times.
Fly over the 12th tree.
Graft the tree 33 times.
 
 
Visit the 1st forest.
Fly over the 1st forest.
Visit the 3rd tree.
Fly over the 1st tree.
Graft the tree 13 times.
Fly over the 2nd tree.
Graft the tree 1 times.
Fly over the 3rd tree.
Graft the tree 1 times.
While the 2nd tree in the 1st forest is less well-rooted than the 1st tree in the 1st forest.
    Fly over the mother forest.
    Fly over the (<1st> 2nd)th tree.
    Give advice.
    Fly over the 1st forest.
    Fly over the 2nd tree.
    Plant the 3rd sapling around the 2nd tree.
Sterilize tools.

Calculator

Visit the 3rd tree.
Propagate the 1st tree 3 times.
Propagate the 2nd tree 4 times.
Propagate the 3rd tree 5 times.

Fly over the 1st 1st tree.
Take recommendations.
Fly over the 1st 2nd tree.
Take advice.
Fly over the 1st 3rd tree.
Take recommendations.

Fly over the 2nd 1st tree.
Graft the tree 43 times.
Fly over the 2nd 2nd tree.
Graft the tree 45 times.
Fly over the 2nd 3rd tree.
Graft the tree 42 times.
Fly over the 2nd 4th tree.
Graft the tree 47 times.

Fly over the 3rd 1st tree.
Graft the tree 69 times.
Fly over the 3rd 2nd tree.
Graft the tree 82 times.
Graft the 3rd 2nd tree in the mother forest to the 3rd 3rd tree in the mother forest.
Fly over the 3rd 4th tree.
Graft the tree 79 times.
Graft the 3rd 2nd tree in the mother forest to the 3rd 5th tree in the mother forest.

If the 1st 2nd tree in the mother forest is as strong as the 2nd 1st tree in the mother forest.
    Plant the 1st 3rd sapling around the 1st 1st tree.
Sterilize tools.
Or else.
If the 1st 2nd tree in the mother forest is as strong as the 2nd 2nd tree in the mother forest.
    Destroy the 1st 3rd sapling around the 1st 1st tree.
Sterilize tools.
Or else.
If the 1st 2nd tree in the mother forest is as strong as the 2nd 3rd tree in the mother forest.
    Spray the 1st 3rd sapling around the 1st 1st tree.
Sterilize tools.
Or else.
If the 1st 2nd tree in the mother forest is as strong as the 2nd 4th tree in the mother forest.
    Decimate the 1st 3rd sapling around the 1st 1st tree.
Sterilize tools.
Or else.
    Fly over the 3rd 1st tree.
    Give advice.
    Fly over the 3rd 2nd tree.
    Give advice.
    Fly over the 3rd 3rd tree.
    Give advice.
    Fly over the 3rd 4th tree.
    Give advice.
    Fly over the 3rd 5th tree.
    Give advice.
Sterilize tools.
Sterilize tools.
Sterilize tools.
Sterilize tools.

Fly over command constructed with objects and eval.

I used some of the obfuscation tools provided by Specification 2.0 in order to make this program a giant square (80 characters wide, so you can put it on punched cards for the ancient 4est mainframe you of course have lying around). Yes, this is the same language as the examples before it, it just looks crazy because of some preprocessor tricks combined with several levels of unusual escape schemes.

?_Pre[NLEscapeDelayStart<-:$?_Pre[SpaceSub:_**_**_**_**_**_**_**_**_**_**_**_^_^
4est`is`a`tree`based`esolang`by`[[User:BoundedBeans))`featuring`nested`tree`dat$
`structures.`This`was`the`first`esolang`he`created,`so`it`is`quite`bad.````````$
==Storage==````````````````````````````````````````````````````````````````````$
The`way`it`stores`data`is`in`a`variety`of`places:`One`or`more`outer`trees,`each$
node`containing`an`inner`tree.`The`inner`trees`are`confusingly`referred`to`as`f$
rests`(NOT`the`outer`trees),`while`individual`VALUES`in````````````````````````$
4est`is`a`tree`based`esolang`by`[[User:BoundedBeans))`featuring`nested`tree`dat$
`structures.`This`was`the`first`esolang`he`created,`so`it`is`quite`bad.````````$
==Storage==````````````````````````````````````````````````````````````````````$
The`way`it`stores`data`is`in`a`variety`of`places:`One`or`more`outer`trees,`each$
node`containing`an`inner`tree.`The`inner`trees`are`confusingly`referred`to`as`f$
rests`(NOT`the`outer`trees),`while`individual`VALUES`in````````````````````````$
`the`inner`tree`are`referred`to`as`trees.`There`can`be`multiple`outer`trees,`kn$
wn`as`continents,`stored`in`an`ArrayList.`There`can`be`multiple`ArrayLists,`kno$
n`as`realities,`stored`in`YET`ANOTHER`tree`structure,`because`everybody`knows`t$
hat`all`the`realities`of`the`multiverse`are`folded`together`into`a`GIANT`PRIMOR$
DIAL`PLUM`TREE.````````````````````````````````````````````````````````````````$
The`individual`values`of`an`inner`tree`are`32-bit`floating`point`numbers`repres$
ented`as`an`integer`(optionally`with`a`hyphen`at`the`start`for`negative)`with`t$
he`comma`as`the`decimal`point``````````````````````````````````````````````````$
(This`language`avoids`the`period`for`anything`other`than`the`end`of`the`stateme$
nt,`at`least`after`preprocessing,`to`allow`a`simple`split`function`to`separate`$
tatements).````````````````````````````````````````````````````````````````````$
```````````````````````````````````````````````````````````````````````````````$
=~=Instructions=~=`````````````````````````````````````````````````````````````$
Instructions`are`separated`by`a`period`followed`by`a`tab,`a`space,`or`a`newline$
.`All`other`whitespace`is`ignored.`"//"`can`be`used`to`comment`out`things`until$
`a`newline.````````````````````````````````````````````````````````````````````$
=~=Basic`operations=~=`````````````````````````````````````````````````````````$
[code>Visit`the`[list`of`ordinal`numbers)`forest.[/code>```````````````````````$
`the`inner`tree`are`referred`to`as`trees.`There`can`be`multiple`outer`trees,`kn$
wn`as`continents,`stored`in`an`ArrayList.`There`can`be`multiple`ArrayLists,`kno$
n`as`realities,`stored`in`YET`ANOTHER`tree`structure,`because`everybody`knows`t$
hat`all`the`realities`of`the`multiverse`are`folded`together`into`a`GIANT`PRIMOR$
DIAL`PLUM`TREE.````````````````````````````````````````````````````````````````$
The`individual`values`of`an`inner`tree`are`32-bit`floating`point`numbers`repres$
ented`as`an`integer`(optionally`with`a`hyphen`at`the`start`for`negative)`with`t$
he`comma`as`the`decimal`point``````````````````````````````````````````````````$
(This`language`avoids`the`period`for`anything`other`than`the`end`of`the`stateme$
nt,`at`least`after`preprocessing,`to`allow`a`simple`split`function`to`separate`$
tatements).````````````````````````````````````````````````````````````````````$
```````````````````````````````````````````````````````````````````````````````$
=~=Instructions=~=`````````````````````````````````````````````````````````````$
Instructions`are`separated`by`a`period`followed`by`a`tab,`a`space,`or`a`newline$
.`All`other`whitespace`is`ignored.`"//"`can`be`used`to`comment`out`things`until$
`a`newline.````````````````````````````````````````````````````````````````````$
=~=Basic`operations=~=`````````````````````````````````````````````````````````$
[code>Visit`the`[list`of`ordinal`numbers)`forest.[/code>```````````````````````$
010101010101010101010101010101010101010101010101010101010101010101010101010101.$
020202020202020202020202020202020202020202020202020202020202020202020202020202.$
030303030303030303030303030303030303030303030303030303030303030303030303030303.$
040404040404040404040404040404040404040404040404040404040404040404040404040404.$
050505050505050505050505050505050505050505050505050505050505050505050505050505.$
060606060606060606060606060606060606060606060606060606060606060606060606060606.$
070707070707070707070707070707070707070707070707070707070707070707070707070707.$
080808080808080808080808080808080808080808080808080808080808080808080808080808.$
090909090909090909090909090909090909090909090909090909090909090909090909090909.$
TenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTenTen.$
0001$Visit_/the_/10th_/tree._^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^
0002$Fly_/over_/the_/1st_/tree._^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_**
0003$Graft_/the_/tree_/_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_**;;RN
0004$>^Class>{"FlyOver":"Fly?20over?20the?20current?20tree?2E?20//!!!!!~~?0A;;RN
0005$Fly?20over?20the?203rd?20tree?2E?0A//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!~~?0A;;RN
0006$Graft?20the?20tree?20?3E^String?3EFly?3F20over?3F20the?3F20?3E0?20times;;RN
0007$?3E?0A//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!?0A;;RN
0008$Fly?20over?20the?204th?20tree?2E?0A//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!~~?0A;;RN
0009$Graft?20the?20tree?20?3E^String?3Eth?3F20tree?3F2E?3F0A?3E0?20times?2E?;;RN
0010$0A//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!?0A;;RN
0011$Fly?20over?20the?current?20tree?2E?0A//!!!!!!!!!!!!!!!!!!!!!!!!!!!!~?0A;;RN
0012$Graft?20the?20tree?20?3E^Concat?3Eroot/0/root/3&self&root/0/root/4?3E0?;;RN
0013$20times?2E?0A//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!~?0A;;RN
0014$Act?20on?20the?20dire?20state?20of?20the?20current?20tree?20in?20the?20;;RN
0015$current?20forest?2E?0A//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!?0A;;RN
0016$"}>0_/times._^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_^_**
0017$Fly_/over_/the_/7th_/tree._/Graft_/the_/tree_/16_/times._^_^_^_**_^_^_^_^_^
0018$Fly_/over_/the_/2nd_/tree._/Graft_/the_/tree_/>^Object>here&root/0/root;;RN
0019$/2>0_/times._/Graft_/the_/tree_/7_/times._/Apply_/FlyOver_/fertilizer_/;;RN
0020$to_/the_/2nd_/tree_/in_/the_/mother_/forest._/Give_/recommendations._^_^_**
0021!00000000000000000000000000000000000000000000000000000000000000000000000$}|]