nyuuzyou/wikis huggingface dataset:
Table

The Table programming language is a programming language by User:Rdococ. It is a basic data description language extended with some minimal set of features required to make it Turing-complete.
== Semantics ==
A Table program is an expression. An expression can be:
* A table -- a list of key-value entries where the key is a symbol and the value is an expression.
* A symbol -- a sequence of alphanumeric characters.
* An 'index' -- an operation that takes two expressions. The result of the right expression is used to retrieve a value from the result of the left.
* An 'update' -- an operation that takes two tables and creates a new table with the entries from both.
If the left side of an index expression is left empty, the current table and its parents are indexed. This permits the creation of recursive tables. There is also a special key symbol, ^, which resolves an index operation to the table's parent. Index operations cannot be substituted until the corresponding entry exists.
The 'update' operation is a deep copy: updated recursive tables maintain copies of the original in their recursive references. This may result in infinite data structures which must then be generated lazily by the implementation.
Execution consists of trying to reduce the program expression into a form where no more reductions can occur.
== Syntax ==
A table is written as a comma-separated list of entries wrapped in braces, and each entry is written as a colon-separated pair.
{
 apples: 1,
 bananas: 1,
 satchel: {
 pies: 1,
 bandages: 2
 }
}
An 'index' operation is written either as a dot-separated pair, if the right side is a symbol, or with the classic a[b] notation otherwise.
satchel.pies
satchel[.item]
An 'update' operation is written as an ampersand-separated pair.
satchel & {unicornHorns: 1}
Precedence order from highest-to-lowest:
* Unary index (if the left side is implicit)
* Binary index
* Update
Parentheses for grouping are fair game.
== Examples ==
=== Boolean logic ===
{
 constTrue: {
 true: true,
 false: true
 },
 constFalse: {
 true: false,
 false: false
 },
 id: {
 true: true,
 false: false
 },
 and: {
 true: .id,
 false: .constFalse
 },
 or: {
 true: .constTrue,
 false: .id
 }
}
=== Truth machine ===
For input, edit the input entry.
{
 input: 0,
 choices: {
 0: {output: 0},
 1: {output: 1, next: .1},
 },
 output: .choices[.input]
}.output
=== Lambda calculus ===
A table with a missing 'input' entry & unevaluated output entry works as a lambda.
{
 id: {r: .v},
 test: (.id&{v: test}).v
}
This makes Table a Turing-complete language. Here is a translation from the lambda calculus to Table:
LC 	Table
\[var].[expr]	{[var]: .v, r: [expr]}
[var] 	.[var]
[func] [expr]	([func]&{v: [expr]}).r
Category:Languages
Category:Turing complete
Category:2015
Category:Unimplemented
TableLang

TableLang is a esolang made by Mihai Popa, based on only tables. :)
== Commands (in tables) ==
 Command list
Command 	Meaning 	
{| class="wikitable"	Command 	Parameters
Set Variable to Value	Variable 	Value
Placeholder 	Something	
== Examples ==
===Hello, world!===
Line Number 	Command(s)	
1 	Command 	Parameters
Print Text 	Text 	
Hello, world!	 	
===Cat===
Line Number 	Command(s)	
1 	Command 	Parameters
Give User Input to Variable	Variable 	
Cat 	 	
===XKCD Random Number===
Line Number	Command(s)	
1 	Command 	Parameters
Print Text 	Text 	
4 	 	
===Truth Machine===
Note that this is the longest program in this language...
Line Number 	Command(s)	
1 	Command 	Parameters
Give User Input to Variable	Variable 	
Truth 	 	
Category:Languages
Category:2024
Category:High-level
Category:Unimplemented
Category:Non-textual
Category:Two-dimensional languages
Tables

Number That Means Nothing	Description 	 	 	 	 	 	 	 	 	 	
00 	Tables is an esoteric programming language by User:SoundOfScripting where all instructions, programs, and modes are made of tables. Programming in Tables will be a nightmare due to the overwhelming amount of tables that must be looked through.	 	 	 	 	 	 	 	 	 	
01 	Tables in whole is less of a single programming language, and more of a table-filled table of programming languages. 	 	 	 	 	 	 	 	 	 	
02 	The commands and instructions used in a Tables program will change depending on the current mode 	 	 	 	 	 	 	 	 	 	
03 	Programs in tables will be made of many tables 	 	 	 	 	 	 	 	 	 	
04 	
{|class="wikitable" 	Some	Tables	May	Even	Have	More	Tables	Inside	Of	Them
Category:Stubs
Category:Languages
Category:Works-in-Progress
Tack

Tack is an esoteric programming language, with only one symbol: !. Tack was made by User: AmNow.
== Commands ==
In Tack, the ! symbol marks to do the command associated with that cell, if there is no !, then the cell won’t be run.
The cell table will loop, and run sequentially e.x.: cell 1 will run if marked, cell 2 will run if marked, etc.
=== Cell table ===
# Push 35
# Input as a number
# Input as string
# ASCII to number
# Swap
# Pop
# Move bottom value up
# Move top value down
# Jump to cell top of stack * 27 (NO POP)
# Divide
# Subtract 
# Push 2
# Duplicate
# Multiply
# Add
# Number to ASCII
# Output
# End Program.
# Jump to beginning Marked cells after it are not run.
# String to number
# Jump to cell Top of stack * 27 if the value below it is non zero. (NO POP)
# Equal
# Logical Negate
# Less than
# Greater than
# Jump to the beginning if the top of the stack is not 0. Marked cells after it are not run.
# Push 4
== Programs ==
=== Spam #s ===
 !12345678901234!!1!
=== Truth machine ===
 1!12345678901!123!1234567890!123456789012345678901!12345678901234567890123456!1234567890123456!12345678!123!123456789012345!123!
== Computational class ==
Tack’s is Turing complete, as multiplicative Minsky machines can be compiled into it. 
Category:Turing completeCategory:2021Category:UnimplementedCategory:LanguagesCategory:Stack-based
Tag system

A tag system is a restricted kind of Post normal system where productions can only be uniquely selected based on the first symbol of each of their antecedents.
==History==
Tag systems were studied by Emil Post as early as 1920. The name comes from the children's schoolyard game, Tag, with the analogy being that one end of the axiom is "chasing" the other.
==Definition==
A tag system can be defined formally as follows:
Wang, H. Tag Systems and Lag Systems, Math. Annalen 152, 65-74 (1963).
Cocke, J., and Minsky, M. Universality of Tag Systems with P=2, J. Assoc. Comput. Mach. 11, 15-20 (1964).
Rogozhin, Yu. Small Universal Turing Machines, Theoret. Comput. Sci. 168, 215-240 (1996).
A tag system is a 3-tuple (m, A, P), where
* m is a positive integer
* A is a finite alphabet of symbols, one of which is a special halting symbol
* P is a set of production rules, assigning some word P(x) to each non-halting symbol x in A; a word is a finite string on A
The term m-tag system (e.g. 2-tag system, etc.) is often used to 
emphasise the parameter m. 
A halting word is a word either that begins with the halting symbol
or whose length is less than m.
A transformation t is defined on the set of non-halting words, such that 
if x denotes the leftmost symbol of a word S, then t(S) is the result of 
deleting the leftmost m symbols of S and appending the word P(x) on the right.
A computation by a tag system is a finite sequence of words produced
by iterating the t-transformation, starting with an initially given word 
and halting when a halting word is produced. (A computation is not
considered to exist unless a halting word is produced by finitely-many 
iterations.)
There are various variants of this definition. E.g. Post's original 1943 version applied appending before deleting, giving only the empty string as halting word.
==Example==
Tag system 
 m: 2
 A: {1,2,3,H} 
 P:
 1 --> 3321H
 2 --> 331
 3 --> 33
Computation
 Initial word: 211
 1331
 313321H
 3321H33
 21H3333
 H3333331 (halt).
==Computational class==
In 1961, Marvin MinskyMinsky, M. Recursive Unsolvability of Post's Problem of "Tag" and other Topics in Theory of Turing Machines, the Annals of Mathematics, 2nd ser., Vol. 74, No. 3. (Nov., 1961), pp. 437–455. gave a method for translating any Turing machine with a given number of symbols into a tag system with a proportional number of symbols, thus showing that tag systems are Turing-complete. Many 2-tag systems have since been proved Turing-complete as well.
==References==
==See also==
* Cyclic tag system
* Bitwise Cyclic Tag
* Platts
* Tag
* UT19
==External resources==
* Tag System on Wikipedia
* A tag system interpreter in Jelly, runnable online at Try It Online! – uses 1-based state numbering, a halt state is specified by giving it the production [0]
Category: Computational models Category: Turing complete Category:Implemented
TailDot

TailDot is an esolang by User:ChuckEsoteric08 based on his old esolangs.
==Specification==
TailDot consits of "words", which are string of characters seperated by commas and 1-indexed. It uses three variables that store integers: a, b and c and three variables that store strings: x, y and z. All TailDot Programs are written in one line.
===Commands===
[argn] is and argument n.
 a - increment integer variable [arg1] by value [arg2]
 s - decrement integer variable [arg1] by value [arg2]
 m - multiply integer variable [arg1] by value [arg2]
 d - divide integer variable [arg1] by value [arg2]
 c - set string variable [arg1] to [arg2]
 j - jump to word [arg1]
 i - set string variable [arg1] to user input
 e - if variable [arg1] is [arg2] goto word [arg3]
 v - output variable [arg1]
 o - square integer variable [arg1]
==Examples==
===Hello, World!===
 c,x,Hello World!,v,x
===Cat===
 i,x,v,x,j,1
===Deadfish interpreter===
 c,x,>>,v,x,i,x,v,x,e,x,i,28,e,x,d,37,e,x,s,46,e,x,o,53,j,1,a,a,1,e,a,256,57,j,1,s,a,1,e,a,-1,57,j,1,o,a,e,a,256,57,j,1,v,a,j,1,a,a,1,e,a,0,1,s,a,1,e,a,0,1,j,64
==External resources==
Interpreter in Scratch
Category:Languages Category:Turing complete Category:Implemented
Taktentus

Taktentus is an simple language with equal. Author is Jacek Szewczyk. Language was created in 2015.
== Syntax ==
 if @ is zero then run <variable1> op <variable2>
 copy variable2 into variable1 with some modifications
op is:
 := assignment
 += add
 -= subtract
 *= multiply
 /= divide
 <= less-than
 >= greater-than
 == equal
 <variable> ++ is short <variable> += 1
 -- is -= 1
 !* is *= -1
 literal = variable, now always integer
 _ = next instructions
 @ = if this variable is 0 instruction is running
 @wy_n = print variable as number
 @wy = print integer as char
 @we = input char as integer
 @spacja = space
 @n = new line
 @losowe = random number
 # =
Comments appear to be denoted by %%.
== Examples ==
 %% sum two values 15 + (-2)
 a := 15
 a += -2
 %% print space
 @wy := @spacja
 %% print 'a' as integer (13)
 @wy_n := a
 %% print 'a' as char
 @wy := a
== External resources ==
Binary executables for Linux,Mac Os X ,Haiku, Windows, examples
* project page 0.9.5
Docker
* simple run docker in small linux
Category:Languages Category:Implemented Category:2015
Talk

Believe it or not, it is inspired by part of Helen's user talk.
==Syntax==
This programming language is not case-sensitive; this means that you can write syntactically correct sentences.
An example program:
Anything_still in here is here for a_reason, if you_want_any of your_messages_blanked just say!~
*if x just y: Conditional statement. Check if a variable x is nonzero, and then conditionally execute the next command y.
*say!x: Output x as a character onto the console if the variable x was not declared.
*x of y: Index a variable x from the list y.
*x in y: y indicates what a for loop does. x indicates the pre-initialized for loop variable.
*x is y: Set a variable x to a value y.
*for x: Repeat the previous statement the value of x times. If x is nothing, iterate over a list.
Now, it is quite clear that this program sets all variables in the list here to here a_reason times. And then, conditionally print ~.
Here is a Hello, world! program:
O is Hello, world!, x in O say!x for nothing.
Category:2019
Category:Languages
Category:Unimplemented
Talk talk:Turing tarpit

pssst... spambots... edit this page so it gets protected... —ehird 19:01, 13 April 2011 (UTC)
Spambot: No.
Other spambot: Yes
Yes
Yes
Yes
Yes
Yes
Yes
Yes
Yes
Yes
Yes
Yes
Yes
Yes
Yes
Other spambot: I'm tired good night.
Other other spambot: Meow!
Uhh wtf - Joaozin003 (talk) 15:21, 25 March 2023 (UTC)
Category:Ideas
Tampio

Tampio is a programming language whose syntax tries to resemble the Finnish language.
== Examples ==
=== Hello world ===
 Kun aloitetaan, tulostetaan teksti "Hello, world!".
== See also ==
* Inflection - The system used in Tampio
* Perligata - Another language that uses inflection
* ORK - A language that tries to be English
== External links ==
* Github page with description of language, compiler, and examples
Category:Languages
Category:2017
Category:Implemented
Category:Pseudonatural
Tandem/Tandem.hs

:
Here is an skeleton of an interpreter for Tandem, written in Haskell.
It is "strictly deterministic", does not implement parsing, I/O, or other niceties, and reflects the new, post-June 25th definition of &.
(It is however not well tested.)
module Tandem where
import qualified Data.Map as Map
type Label = String
data Rule = Zero
 | One
 | RewExact Label String String
 | RewReplace Label String String
 | RewFront Label String String
 | Disj Rule Rule
 | Conj Rule Rule
 | Many Rule
type Collection = Map.Map Label String
get l c = Map.findWithDefault "" l c
put l b c = Map.insert l b c
startsWith s "" = True
startsWith "" s = False
startsWith (c1:s1) (c2:s2) = c1 == c2 && startsWith s1 s2
stripFront "" s = s
stripFront s "" = ""
stripFront (c1:s1) (c2:s2) = stripFront s1 s2
rewrite :: Rule -> Collection -> Maybe Collection
rewrite Zero c = Nothing
rewrite One c = Just c
rewrite (RewExact l a b) c =
 if (get l c) == a then Just (put l b c) else Nothing
rewrite (RewReplace l a b) c =
 if startsWith (get l c) a then Just (put l b c) else Nothing
rewrite (RewFront l a b) c =
 if startsWith (get l c) a then Just (put l (b ++ (stripFront a $ get l c)) c) else Nothing
rewrite (Disj r1 r2) c =
 case (rewrite r1 c, rewrite r2 c) of
 (Nothing, Nothing) -> Nothing
 (Just c1, Nothing) -> Just c1
 (Nothing, Just c2) -> Just c2
 (Just c1, Just c2) -> if c1 == c2 then (Just c1) else error "choice of more than one redex"
rewrite (Conj r1 r2) c =
 case (rewrite r1 c) of
 Nothing -> Nothing
 Just c1 -> rewrite r2 c1
rewrite (Many r) c =
 case (rewrite r c) of
 Nothing -> Just c
 (Just c') -> rewrite (Many r) c'
Category:Implementations
Tangle bracket language

A Tangle bracket language is a programming language where brackets can be "tangled," that is, written without being properly nested. In properly-nested brackets, the beginning and end of a "clause" of brackets must enclose a complete sequence. This means that these sequences are properly nested:
 ()
 []
 {[]}
 {()[]{}}
And these are not:
 {[}]
 {([{)}])
 (([[)])]
An example of code written in an (ad-hoc) tangle-bracket language is:
 while x {
 if y [
 doSomething();
 }
 doSomethingElse();
 ]
In this code, it is assumed that [...] and {...} can be used interchangeably, but not equivalently- head{body} and head{body} are equivalent, but head{body] and head[body} are not, since ] cannot close {.
Due to the confusing, headache-inducing nature of tangle-bracket grammar, no known practical programming languages invoke this convention. As such, the exact behavior of tangle-bracket code is not defined even by convention; however, one interpretation suggests that the above code (assuming there aren't any side effects of doSomething() or doSomethingElse()) may be equivalent to:
 while(x && y) doSomething();
 if(!x) doSomethingElse();
Category:Concepts
Tanscii

tanscii is a mix of tanstore and ASCII
== what ==
 0 space
 1-26 alphabet lowercase
 27-52 alphabet uppercase
 53 newline
 54 !
 55 "
 56 #
 57 $
 58 %
 59 &
 54-59 ascii 33-38
 60-69 numberbet
 70 '
 71-72 ()
 73 *
 74 +
 75 ,
 76 -
 77 .
 78 /
 70-78 ascii 39-47
 79 :
 80 ;
 81-83 <=>
 84 ?
 85 @
 79-85 ascii 58-64
 86-89 [\]
 90 ^
 91 _
 92 `
 86-92 ascii 91-96
 93-96 {|}
 97 ~
 98 delete
 93-98 ascii 123-127
 99 interpret next 3 as unicode
Category:Concepts
Tape

A tape is the traditional data storage unit of a Turing machine. A tape is divided into cells (Turing originally called these squares). Each cell may contain one symbol drawn from a finite alphabet (which generally includes a blank symbol).
A tape is typically accessed by means of a single read/write head, but variations may have multiple heads, each of which may be restricted to either read- or write-only. The cell which the head is over at any given time is called the current cell.
A standard tape can be thought of as an abstract data structure which supports the following operations:
* Left(t): move the head one cell to the left
* Right(t): move the head one cell to the right
* s ← Read(t): return the symbol in the current cell
* Write(t, s): write the given symbol into the current cell, destroying whatever symbol was previously written there
The original tape of Turing's machine was infinite in both directions. Subsequent formulations of the Turing machine have often restricted it to being infinite towards the right only (implying that the Left() operation can sometimes fail - this is considered to be the same as a hang) and starting at the leftmost position.
The tape is generally considered to be initially filled with blanks. However, it can also be considered to contain initial input, as there is no other way to specify input for a traditional Turing machine.
The tape need not be considered "really infinite," only unbounded in the sense that if the head ever exceeds the bound, a new blank cell is added to the tape at that position.
See :Category:Cell-based for more tape-based esolangs.
Category:Data Types and Structures
TapeBagel

TapeBagel is an esoteric programming language that uses an integer array of three integers to make up most of the commands and operators. It was made by S. R. Farmer in May, 2006, a full time SDK is currently in the works. The commands and operators consist of two to seven special characters such as the pound sign etc. The first character or set of characters tells which class the operator is in. The second character or set of characters will have another character telling which command or operator in that class (see below).
== Classes ==
Command Classes
% - deals with the integer index
# - deals with all of the integers
& - deals with miscellaneous commands
Operator Classes
& - deals with multiplication
+ - deals with addition
$ - deals with division
- - deals with subtraction
@ - deals with outputting text
* - deals with integer 0
** - deals with integer 1
*** - deals with integer 2
^ - deals with powers
== Commands ==
%# - adds one to the integer index
%% - resets the integer index to zero
%& - the integer that the integer index is pointing to is inputted into the program
#% - sets all of the integers to one
## - resets all of the integers to zero
&& - pauses the program
&@ - clears the screen
%++ - adds one to the integer that the integer index is pointing to
== Operators ==
* - integer 0
** - integer 1
*** - integer 2
[int]&[int] - integer * integer
[int]+[int] - integer + integer
[int]$[int] - integer / integer
[int]-[int] - integer - integer
@[int] - outputs the integer as a character (1 = A, 2 = B, ... 26 = Z)
@@[int] - outputs the integer as an integer
== Example Programs ==
Hello, World!
This code outputs HELLO WORLD. 
 %% %++ %++ %++ %++ %++ %++ %++ %++ @* ## %++ %++ %++ %++ %++ @* ## %++
 %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ @* @* ## %++ %++ %++ %++
 %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ @* ## @* %++ %++ %++ %++
 %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
 %++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
 %++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
 %++ %++ %++ %++ %++ @* ## %++ %++ %++ %++ %++ %++ %++ %++ %++ %++
 %++ %++ @* ## %++ %++ %++ %++ @* ##
== Implementations ==
An attempt, extrapolating from this incomplete spec, by Oren Watson.
Category:Languages
Category:Unimplemented
Category:2006
TapeFuck

TapeFuck is another Brainfuck derivative.
TapeFuck operates on two tapes: one is the classic Brainfuck tape containing 30,000 positions initially filled with zeros and is arranged on a horizontal axis. The other tape consists of classic eight Brainfuck commands and is arranged on a vertical axis. TapeFuck programming involves moving the two tapes (a command tape and a data tape) accordingly and then executing the selection.
=== Commands tape ===
 0: >
 1: <
 2: +
 3: -
 4: .
 5: ,
 6: [
 7: ]
=== Data tape ===
 0 0 0 0 0 0 0 0 0 0 0 ...
 ^
 0 1 2 3 4 5 6 7 8 9 10 ...
== TapeFuck commands ==
 > - increment data pointer
 < - decrement data pointer
 ^ - decrement command pointer
 v - increment command pointer
 x - execute command on specific data
 [ - If the cell pointed to by the data pointer is zero, jump after matching ]
 ] - If the cell pointed to by the data pointer is non-zero, jump after matching [
== Examples ==
soon
Category: Brainfuck derivatives Category:Languages Category:2024 Category:Cell-based Category:Turing complete
TapeRun

TapeRun is a stack-based programming language which aims to take programmers back to a simpler time. The program consists of a tape, the has a command for each line, and one character is used as the alignment character, to ensure everything runs smoothly.
Here is the rundown of the tape commands.
 |# Take character as input onto the stack
 # | Output top of stack as character
 ##| Pop top of stack
 # |# Clone top of stack
 #|# Add to top of stack
 #| Run until equal to value (represented in 3 bit binary until next separator, runs until the separator after that)
 ##|# Close for above statement
Since loops are a bit difficult to explain, here is an example:
 #| Start loop
 ##| 6 +
 ##| 6 +
 # | 4 =
 ##|# 16
 #|# Add one until the top of the stack is 16
 ##|# Close loop
Note that the binary representation of 6 is used instead of 7 because 7 is ##|#.
For comments the language will only take in the first 4 characters of each line, so any characters afterwards are ignored.
Here is now "Hello World!":
 # |# Create initial stack value
 #| Start loop
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 =
 ##|# 72
 #|# +1 to top of stack
 ##|# Run until top of stack is 72 ("H")
 # | Output "H"
 #| Start loop
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 # | 4 =
 ##|# 100
 #|# +1 to top of stack
 ##|# Run until top of stack is 100 ("d")
 # |# Clone top of stack
 #|# +1 to top of stack
 # | Output "e"
 #|# +1 to top of stack
 #|# +1 to top of stack
 #|# +1 to top of stack
 #|# +1 to top of stack
 #|# +1 to top of stack
 #|# +1 to top of stack
 #|# +1 to top of stack (It is now at "l")
 # | Output "l"
 # | Output "l"
 # |# Clone top of stack
 #|# +1 to top of stack
 #|# +1 to top of stack
 #|# +1 to top of stack (It is now at "o")
 # | Output "o"
 # |# Clone top of stack
 #| Start loop
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 #| 2 =
 ##|# 32
 #|# +1 to top of stack (Wraps back around at 255)
 ##|# Run until top of stack is 32 (" ")
 # | Output " "
 #| Start loop
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 #|# 6 =
 ##|# 87
 #|# +1 to top of stack
 ##|# Run until top of stack is 87 ("W")
 # | Output "W"
 ##| Pop top of stack
 # | Output "o"
 #| Start loop
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 =
 ##|# 114
 #|# +1 to top of stack
 ##|# Run until top of stack is 114 ("r")
 # | Output "r"
 ##| Pop top of stack
 # | Output "l"
 ##| Pop top of stack
 # | Output "d"
 #| Start loop
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 ##| 6 +
 #|# 3 =
 ##|# 33
 #|# +1 to top of stack
 ##|# Run until top of stack is 114 ("!")
 # | Output "!"
Here is the python interpreter.