Oh!  I forgot to mention something really important about recursive subroutines!

Even thought they take up more space in the program than the regular subroutines, there is a new way to optimize them.  The "last expression" for each argument is the original argument.  What I mean, is that instead of this:

sub(FAC^r,r₁-1)

You can actually write this:

sub(FAC^r,-1)

Because the r1 is implied.  Same thing applies to r2, r3, etc in the rest of the arguments.  For any actual recursion, its an extremely important optimization since generally you use the previous value in your expression for the next value passed.

Interesting, nice to know indeed

One example is that you can create multi-byte data abstractions.  Lets say you want to define a "vector" which has a 16-bit X component and a 16-bit Y component.  Conveniently, you can store these in consecutive addresses.  Like A would be the X-part and B would be the Y-part.  Now, lets say you want to write a routine that adds 2 vectors and stores the result in a 3rd vector.  You can do this with a singe routine by pasing the pointer to the vector instead of the vector values themselves (since you can only pass 16-bit numbers at a time):

:.Add 2 vectors
:.Vector 1 pointer in r1
:.Vector 2 pointer in r2
:.Resultant vector pointer in r3
:Lbl ADD
:{r1}r+{r2}r->{r3}r
:{r1+2}r+{r2+2}r->{r3+2}r
:Return

So the first line you're adding the X components and the second line you're adding the Y components.  You can use this code for example like this:
:.Initialize vector A with (10,20)
:10->A
:20->B
:
:.Initialize vector C with (5,-10)
:5->C
:-10->D
:
:.Add the vectors and store the result into vector E
:sub(ADD,°A,°C,°E)

So now the E holds 15 and F holds 10 thus the vector E has value (15,10).  You can also call the same routine with L1 instead of °E for instance which would save the vector to the locations {L1} through {L1+3} instead of to one of the Axe variables.

The best way to think about the dereferenced variables is like you think about the L1-L6 pointers.  Each variable has it's own "free-ram" (exactly 2 bytes of it) so just like you can get a  free ram location using L1, you can now get the ram location of any variable.  The biggest difference is that when you want to read from a variable, you can just type the letter of the variable so it saves you a lot of typing.  If you wanted to get the ram in L1 on the other hand, you would have to do {L1}r.  And yes, that means that {°A}^r is exactly the same as just typing A.

does this mean that 0->A->B->C etc to J (or some other later value) can now be written as
:for([some variable outside the set to be initialized,0,[number of vars minus one]
:0->{[counter var]*2+°A}^rEnd
?

is that more efficient size wise than the huge list above?

So, in essence, dereferencing is just directly using the variables as chunks of memory instead of changing the value of the variable?

What you say would work but for this fact:

I would suggest you only say that when code passes that mark, but then I remembered that you decided to mix subroutines and code

I think he meant mixing subroutines and data.

There has always been support for inline data with the Asm() command.  It literally just inserts the hex code right there.  But the other data like strings are still added to the data section at the end of the program, it just doesn't assign a name to the pointer.