nyuuzyou/wikis huggingface dataset:
.exe

.exe is a programming language that takes a .exe file as its source code. So technically, you could say that you coded Minecraft using .exe.
==Code execution==
Jokes on you, it just runs the .exe file.
So, to write a program, do it in any other language you want.
==Examples==
===Hello, World!===
A Hello, World! program can pretty much be written with any language you want. Here are some examples:
====Python====
 print("Hello, World!")
====C====
 #include <stdio.h>
 
 int main() {
 printf("Hello, World!");
 return 0;
 }
====C++====
 #include <iostream>
 
 int main() {
 std::cout << "Hello, World!";
 return 0;
 } 
====Javascript====
 function main() {
 console.log("Hello, World!");
 }
====brainfuck====
 >++++++++[>+++++++++>++++++++++++>+++++++++++++>++++++++++++++>++++++>++++>+++++++++++>++++++++++++++[<]>-]>.>+++++.>++++..>-.>----.>.>-.<<<.+++.<.<-.>>>>+.
====><>====
 "Hello, World!"0r>:o?v;
 ^ <
====Befunge-93====
 <v"Hello, World!"
 >,,,,,,,,,,,,,@
====Random-ass Turing Complete Language====
 ca
 "a
 Hello, 'a "a
 world!
 -asr
 -aoc -aoc -aoc -aoc -aoc -aoc -aoc -aoc -aoc -aoc -aoc -aoc -aoc
====AsciiDots====
 .-$"Hello, World!"
==== +Output ====
 "Hello, World!"oX
===A+B problem===
The A+B problem is a popular problem which takes 2 numbers as input and outputs their sum.
====Python====
 a = int(input())
 b = int(input())
 print(a + b)
Or, the minimised form:
 print(int(input()) + int(input()))
====Brainfuck+2====
 ';>;<[>+<-]>:
==== +Output ====
 i&i&+oX
====C++====
 #include <iostream>
 using namespace std;
 
 int main() {
 int a, b;
 cin >> a >> b;
 cout << a + b << endl;
 return 0;
 }
====><>====
 ii+n;
====Befunge-93====
 &&+.@
====Random-ass Turing Complete Language====
 ca
 -aii -aii
 -aa+
 -aoi
====Drive-In Window====
Note: I haven't tested this yet, and I don't exactly know if this will work.
 Hi, welcome to A Plus B Restaurant. Here is a menu.
 
 Addend 1: $10
 Addend 2: $20
 
 May I take your order?
 
 OK, how much money should Person 1 have?
 OK, how much money should Person 2 have?
 Person 2 would also like what Person 1 has.
 Person 1 will pay for his order!
 
 OK, that will be $5.94. Thanks for coming!
====Pizza Delivery====
 ?d?a[d+a-]d`.
====AsciiDots====
 .-#?--\
 .-#?-{+}-$#
Category:Joke languages Category:Languages Category:Implemented Category:Low-level
.m@dpr'a'prozessor

By the way in case you have not read the page about .mOdMoDwOrM I recommend you to do so for understanding better what is now coming. 
The m@dpr'a'prozessor creates input data or worm files for moDMoDwOrM, because it hardly can do without that. Its purpose is thus to define how the input data should be processed so that it can be best processed by mOdMoDwOrM. Don't ask me why I have not called it worm creator what it obviously is. 
Suppose we want to write a brainfuck interpreter for moDMoDwOrM, but it can not process the brainfuck input because it is no valid worm , Iworm , worm file or whatever, in the same way hieroglyphs are much likely not understood by your neighbour next door.
So right now some m@dpr'a'prozessor code for the processing of brainfuck. 
 order +
 symbol [ [
 symbol ] ]
 symbol < <
 symbol > >
 symbol + +
 symbol - -
 symbol . .
 symbol , ,
 length c 
 end 
So what does this all mean. The first line means that the order of the brainfuck instructions should be preserved, because that is required for a useful execution of the program. They symbol lines are of importance, because they define what symbols are in the source file and to which moDMoDwOrM symbols they should be translated. It is possible to translate more than one different source file symbols to one moDMoDwOrM symbol.
A source file symbol can be more than one characters long. Thus following would be a valid line of m@dpr'a'prozessor code.
 symbol end q 
By the way I can also explain the first line a bit further. The command order must come first and have one of the following 
parameters + or -. - means that the order of the symbols should be completly ignored and only there quantity of appearance be counted. The order command can appear more than once in a m@dpr'a'prozessor file, but there should be dealed later with it. 
The length c line means that c should contain the number of symbols counted int the source file. (More later)
The end command obviously marks the end of the file and must only occur only once in the file. 
So how is the worm created.
The brainfuck source file
 >+<[]-.
Every occurence of > is marked with 1 , every non-occurence with 0 and
the same with all other symbols. 
 Thus
 
 [ 0001000
 ] 0000100
 < 0010000
 > 1000000
 + 0100000
 - 0000010
 . 0000001
 , 0000000 
Obviously those are binary numbers which are converted to decimal. 
However its better we turn them so that 0000100 gets 0010000. 
 Thus we get 
 [0001000]0010000<0000100>0000001+0000010-0100000.1000000
 and finally 
 [8]16<4>1+2-32.64
So that should be almost the worm file. Remember the length c line. Since we had seven symbols in this sample we just add c7 and thus should get 
 [8]16<4>1+2-32.64c7
 II
By replacing order + with order - we should get
 []<>+-.c7
 II
Category:2014
Category:Languages
Category:Unimplemented
.not required

Made by Unicodes
This is a stack-based language, where you have to start every line with not.
 Instructions
Instruction 	Action
(not) pop [NUMBER] 	pushes [NUMBER] onto the stack
(not) push 	pops the 1st value off the stack
(not) get 	prints out the 1st value
(not) print 	gets a number from the user and adds it to the stack
(not) while [NUMBER/1ST STACK VALUE] =/>/< [NUMBER/1ST STACK VALUE]	if [NUMBER/1ST STACK VALUE] is equal to/bigger than/smaller than [NUMBER/1ST STACK VALUE], execute next instruction, else skip
(not) if [NUMBER/1ST STACK VALUE] =/>/< [NUMBER/1ST STACK VALUE] 	while [NUMBER/1ST STACK VALUE] is equal to/bigger than/smaller than [NUMBER/1ST STACK VALUE] execute next instruction repeatedly, else skip
(not) go 	break (not) if loop
(not) execute 	quit
Category:Languages Category:Stack-based Category:Unimplemented Category:Push-down automata
.yacuabll

.yacuabll (Yet Another Completely Useless And Badly Labelled
Language) is an esoteric programming language created by Gerson Kurz in 2001.
== Example Program ==
{.#,#H#E#L#}.#,#L#O# #b.#,#W#O#b.#,#R#L#:.#}.#,#D# #T#H#I#}.#,#S# #F#I
NE PROGRAM DOES NOT
NECESSARILY ##}.#,######}.#,######
}.#,#
#
#
#
#
:
.
# THIS SPACE FOR RENT
}
.
#
,
#
#
#
}
.
#
,
#
#
#
#
:.#:.#}.#,###WORK:.#{.##,####b.##,##b.##,####:.##
b.##,###>.##,####>.##,####>.##,#:.##:.#}.#,#AS##:.#>.#,######:.#>.#,####>.#,####
:.#
==External resources==
* Mailing list announcement (search for .yacuabll)
* .yacuabll website
Category:Languages
Category:2001
.⍸.

.⍸. (pronounced: nose) is an esoteric programming language made by User:AmNow, It was directed to look like emoticons with noses.
== Commands ==
 ⍸ (Monadic): Save to the location of the pointer.
 ⍸ (Dyadic): if x is not 0 jump to instruction y. instructions start at 0.
 ⍸ (Niladic): Load the pointer as the number of dots directly~ after this command.
 .: The number of dots in a row is the integer it represents, minus 1.
 ⨪ (Monadic): Output as a number.
 ⊙ (Monadic): Output as a Unicode Character.
 (): Grouping.
 - (Monadic): Logical NOT
 - (Dyadic): Shift the data pointer right
 - (Niladic): Shift the data pointer left
 
Every other character is ignored.
Operators can be forced to be a specific type, which can be done using parentheses.
~ If it looks like: ()⍸(), it will load after the directly after second set of parentheses.
== Programs ==
=== Spam #s ===
 ……………………………..⊙(..⍸.)
=== Infinite loop ===
 ..⍸.
== Computational Class ==
Language is Turing Complete, because it can simulate Smallfuck with Goto instructions
Category:LanguagesCategory:2021Category:Turing completeCategory:Unimplemented
/

_/ also known as water and a wall is a esolang created by User:Yayimhere where you replace bits with other bits n' stuff
== syntax ==
so the basic syntax is:
 (x)_/y
x is setup like this:
 x./y¯\
so what this pattern does is:
* check for bit pattern x
* replace it with y
and y us just a list of bits. so for example if its set up like dis:
 (10./110¯\)_/10
produces:
 10
 110
 1110
 11110
 111110
 1111110
 11111110
and so on. if a result is ¨\ it will print the productions. each line is checked top to bottom(unless a X/ to the end of a line which will make it force executed as the first. the program halts when no more things can be applied. note that y in the x syntax is the results and x is the input, while in the y section is called the production. also if a bit is replaced with :/ it will be replaced with the line below's production and replacing with l/ it will take user input(as a list of bits) and set the production to that.
== examples ==
Truth-machine:
 (0./¯\1./¨\¯\)_/:/
 ((10./110¯\))_/l/0X/
Looping counter(with 1 as *):
 (0./¯\1./¨\¯\)_/:/
 (10./110¯\)_/10
Category:Languages category:String-rewriting paradigm Category:Unknown computational class
/gɹəʊguː/

/gɹəʊguː/ is an esoteric programming language by User:PythonshellDebugwindow.
==Memory==
/gɹəʊguː/ uses two signed unbounded integer registers: nr (Number Register) and dm (Deep Memory).
==Commands==
Command	Meaning
[ 	Output [no output]
; 	Input an integer to nr (set nr to 0 for an invalid integer)
] 	Jump to after the previous [ (or to the start of the program if there are no previous [s) after appending [ to the end of the program
&d 	Add d to nr (d must be a digit from 0 to 9)
< 	Decrement nr
! 	Skip the next command iff nr < 0
, 	Print the result of floor dividing nr by 2
+ 	Add nr to nr
- 	Subtract nr from nr
{ 	Set dm to nr
} 	Set nr to dm
? 	Halt the program
==Examples==
===Truth-machine===
 ;{-<![}+,}<!]?
===Integer cat program===
Halts on input 0 or an invalid integer. This program is similar to the truth-machine program, as it essentially just takes another input and uses { instead of }.
 ;{-<![}+,;{<!]?
===Countdown===
The following program expects a nonnegative user input and prints the numbers starting from the same down to zero. For a negative start value only the input itself will be printed.
 ;&1{-<![}<{+,-}<!]?
==Interpreter==
* Common Lisp implementation of the /gɹəʊguː/ programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Languages Category:2020 Category:Implemented Category:Unknown computational class
0

== Instructions ==
 0 - calculates 0
Note that it is somewhat ambiguous what 'calculate' means.
Moreover, presumably [INSTRUCTION OTHER THAN ZERO] is UB, but this is unspecified.
== Programs ==
=== Quine ===
 0
=== IQ Test ===
 0
== Implementations ==
=== Haskell ===
 main=interact(\('0':_)->show 0)
Alternative implementation:
 main=print 0
=== Shell ===
Interpret a file:
 cat
Interpret a command-line argument:
 echo
Alternative implementation:
 yes 0
=== Struffoli ===
 59536$00000000@@0@0@!0
=== Text ===
 0
=== Python ===
 print(0)
=== Befunge ===
 0.@
=== Deadfish/eafh ===
 o
=== FlipFlop ===
 PE
===G#===
 make main;[print(0+"\n")]
Using a function:
 make 0;[print(0+"\n") return{x}]
===15 or 35===
 #
===Txet===
 i`d0`0
Category:Languages
Category:Implemented
Category:Unusable for programming
Category:Total
Category:Output only
0(nop^)

0(nop^) is an esoteric programming language with numeric function names that are evaluated with the " ^ " command. This is the only form of flow control. 
== Commands ==
+, -, *, /, %, <, >, and = work as expected.
_ : Negate tos (top of stack).
~ : Replace tos with 8-bit sine wave table look-up.
? : Replace tos with random number if tos is not zero, else with the last random number given.
$ : Duplicate tos.
\ : Swap top two elements.
@ : Rotate top three elements.
& : Returns the "pointer" to a string.
! : Assign second top element to the pointer given by top element, points to less than 1st string/function, assign to the stack
# : Pick an element from a string given by a pointer at tos. Smaller pointers return elements from the stack.
( : Start pushing chars to pad.
) : Stop pushing chars to pad. If a valid integer is written before this symbol, evaluate that function.
^ : If inside parens, save pad to function given by tos (0 = stack) including " ^ " and clear pad, else evaluate function given by tos. If tos is greater than 32, evaluate that ascii character. Execution continues as long as functions with names greater than 0 are evaluated.
" : If inside parens, save to string given by tos not including " ^ ".
. : Write char at tos.
, : Wait for user input and push first char.
| : Wait for user input, and push are chars to string given by tos. If top of stack is 0 push chars to stack.
` : If tos is 0, print stack else print string at tos if it does not contain " ^ ". 
[ : Begin storing filename.
] : Stop storing filename, and push file contents to pad.
 
== Examples ==
=== Hello, World! ===
 1$(Hello, World!
 ")`
=== Cat ===
 1(,.1^1)
=== Quine ===
 1(49.40.1`34.41.10.50.40.1`94.50.41.0")
 2(49.40.1`34.41.10.50.40.1`94.50.41.0^2)
=== Self-interpreter ===
 31(26(^)62.62.0 21&1-!0 94 53 50 32 0|29^)
 29($0=27+^)
 28(21&1-#26&+!26^)
 27(21&1-$#$1+@!26&+!$ 94=29+^)
 30($--94 43 42 53 50 61 48 36 48 27&17+!29^)
 25(36 27&17+!0`31^)
 21(22(22 0^)0 21&2-!24^)
 24(21&2-$#$1+@!$3&+#$@22&+4+!0=24\-^)
 23(93 21&2-#22&+3+$@\!1+$48\!1+$94\!1+$41\!1+$50\!1+$50\!1+94\!40 22&2+!91 22&3+!22^)
 3�=10*21+^
== See also ==
* Spaghetti a similar language
== External resources ==
* 0(nop^) interpreter written in C
Category:Languages
Category:Implemented
0+

0+(pronounced 0 plus) is an esolang made up of only plusses and zero's. it was created by User:Yayimhere. theres an infinite to the right array holding numbers named acc and a function named f
== commands ==
 0 = 0
 x+ = x+1
 0x0 = do x before everything else(if multiple they are evaluated left to right the rest of code)
 x+y = x-y
 x++y = while x ≠ acc[x] do y
 x+y0 = f(acc[y])=acc x. to make x empty replace with 0
 +++x = acc[x] = f(acc[x])
spaces separate commands and are NOPs
== examples ==
Infinite loop
 00+0++0
== computational class ==
idk but i think its TC
Category:Languages Category:2024 Category:Unknown computational class
0134

0134 is a esolang with 9 commands, created by User:Yayimhere. it was created to look like a random string of numbers(which it does)
== syntax ==
0134 has these 9 commands:
* 1 flip the end of the code(so 0 <-> 1, 6 <-> 4, 7 <-> 0, 5 <-> 2, 3 <-> 0).
* 0 add the following command to the end of the code(and skip it).
* 2 reverse the line below.
* 3 skip the following command.
* 4 if the command before the command is equal to the start of the line below it will run the command after the 4.
* 5 delete the end of the code.
* 6 add a newline to the end of the program.
* 7 skip the line below when the IP gets to the end of the current line.
* 22 since this is a NOP, if it isn't a command, it will go back to the start of line if there is not a empty line below. else do nothing.Since the command 22 will confused by two 2's, so you can also to write it as 8.Another variant is spaced 2's for command 2, and continuous couple 2's for command 22.
== computational class ==
0134 is Turing-complete since it can simulate a BCT like this:
the program must start with this:
 program 227
 memory
and the commands are replaced like this:
 11 -> 31401
 10 -> 31400
 0 -> 252
so the Collatz sequence program:
 314003140131400314003140031401252314013140031400252314013140031400314013140031400314013140031400252252252252227
 100
note that the number of times 100 is added to the memory is the function input
Category:Languages Category:String-rewriting paradigm Category:Turing tarpits Category:Self-modifying
0587

0587 is a functional esolang that is made up of numeric instructions. It was created by user:InfiniteDonuts and is inspired by 0815, Unlambda, and 1337.
== Instructions ==
Instruction	What it does
0 	Applies the lambda function after it to whatever is after that lambda function.
1 	Defines a lambda function.
2 	Gets the current function's argument.
3 	Returns the current function.
4 	When applied to something, prints it and returns it unchanged.
5 	Gets input.
6 	Returns its argument plus one.
7 	Returns its argument minus one.
8 	If its argument is equivalent to (0), returns the identity function.
9 	Null value.
(n) 	Returns the literal value of n, rather than its 0587 value.
== Program Structure ==
An 0587 program consists of one function application. Due to higher-order functions, this isn't as bad as it sounds; You can create functions inside of functions! For example, this program does a "Hello World" in a fancy monadic way:
 0
 104029
 1(Hello World)
(Code is indented for readability)
As you can see, the program takes a function that calls 4 on its argument to a function that returns "Hello World".
== Monads and Closures ==
Monads are a very important concept in 0587. But instead of being a value wrapped in an algebraic datatype (like in Haskell), they are a value wrapped in a function.
It's pretty simple to create a monad. Just write this:
 1(Hello World)
In this example, "Hello World" is being held inside an anonymous function.
Getting the value out of a monad is substantially more tricky. There is a function combination for retrieving a value from a monad:
 1029
This lambda function, when applied to a monad, will apply 9 (or null) to it and return the result. Since monads don't care about their arguments, you can safely call it with 9 and get the result. In fact, that's why 9 was included with the language in the first place.
Monads are important because of closures. Closures are lambdas that contain something from another scope. All closures (in 0587 at least) are monads because they are just a value wrapped in a function.
== Example Programs ==
=== Hello World ===
 04(Hello World)
Or a fancier way:
 01040291(Hello World)
== Interpreters ==
Interpreter written in Node.js by User:Hakerh400
Category:Languages
Category:Functional paradigm
Category:Implemented
Category:2020
0 Bits, 0 Bytes

0 Bits, 0 Bytes is yet another ___ Bits, ___ Bytes language and the most useless one. With 0 bytes of memory, this language can store 0 instructions. If there are more than 0 characters, the interpreter takes the first 0 characters. This esolang is designed to be the polar opposite of 6 bits, 12 bytes.
==Commands==
No commands, but control flow still wraps around.
==Examples==
===Infinite loop===
 
==Implementations==
===Python===
 while 1:pass
===Befunge===
 >v
 ^<
or
 ~
===brainfuck===
 +[]
===Self interpreter===
 Any text can go here
===C++===
 int main(){while(1){continue;}}
===LUA===
while 1 do
 --NOP
end
===wenyan===
恆為是。
	噫。
云云。
===！中文===
重复循环一个啥也不做的代码。
===5===
 {0B0B}
===How to learn this language===
iq or q
==See also==
* Infinite loop
* Recursive
Category:Languages
Category:Joke languages
Category:2024
Category:Implemented
Category:Unusable for programming
Category:No IO
Category:No-code esolang
0 bytes XD

0 bytes XD is an esolang by User:None1 and inspired by 9 bytes :I which is inspired by 13 bytes :D which is inspired by 16 bytes :P which is inspired by 25 bytes o:. 0 bytes XD effectively views truth machines as interpreters.
==Syntax==
There are 2 programs:
 0
Outputs 0
 1
Outputs 1 infinitely.
Behavior of programs other than 0 and 1 are undocumented.
==Examples==
===Quine===
 0
===Truth Machine===
 <input goes here>
Replace with the input.
==Interpreter==
===™ type 3===
User:Nomad was here. And yes, I spent a whole minute writing this. 
===Node.js:===
while (process.argv[2]?.[0]) process.stdout.write(1); // Save to a file and call 'node <filename> '
===Python3===
i=input()
if i=="0":
 print(0)
if i=="1":
 while True:
 print(1)
==See also==
* The page Truth Machine, provides a long list of implementations of 0 bytes XD in other languages.
Category:Languages
Category:Joke languages
Category:Output only
Category:Unusable for programming
Category:Implemented
Category:2023
0bIN

A programming language that uses only binary*
(*You need to convert the symbols into binary)
The name came from 0b and the file extension .bin
 
The Unbined	How to
+ 	add 1 to selected item
- 	subtract
( 	loop based on number (eg, 1())
) 	end loop
[ 	move pointer
] 	move pointer
“ 	string to item
‘ 	input
~ 	escape loop
Convert the symbols to binary, then put them together into one single line
 Caption text
Header text	Header text
0b 	start a line, can begin with a letter or number because function
_ 	do function (eg 1_)
= 	output the selected item
. 	reset the pointer back to 0
$ 	begin program
; 	end program
{ 	start the “normalized” 0bIN code
} 	end the normal cod
: 	seporate
Btw the comments are #
Xkcd Random Number
 $
 0b00101011001010110010101100101011
 =
 ;
Better looking xkcd
 $
 {++++}
 =
 ;
Cat
 $
 0b001100000110001000110000001100010011000100110000001100010011000000110000001100010011000000110001001100010011000000110001001100010011000100110000001100000011000100110001001100000011000000110001001100010011000000110000001100000011000100110000001100010011000000110000001100000011000100110001001100010011000000110000001100000011000100110000001100010011000000110000001100000011000000110000001100000011000000110001001100000011000000110001001100010011000000110000001100000011000000110001001100010011000100110001001100010011000100110000001100000011000000110001001100000011000100110000001100000011000100001010001111010000101000101110
 ;
Better looking version
 $
 {{inf(‘~)}=}
 ;
Hello World
 $
 {“Hello, World!”}
 =
 ;
One line helloworld:
 $:{“Hello, World!”}:=:; #Pretty Short
Category:Languages
0widthnonjoiner

0widthnonjoiner is made by Unicodes.
This language is run on a stack.
For each line there is 1 instruction + arguments.
== Instructions ==
 Instructions
Instruction 	Action
‌ (U+200C) $arg 	Push argument onto stack
‌ (U+200B) $arg 	Pop
‌ (U+200D) $arg 	Do operation on 1st and 2nd element on stack; If argument is 1, add, if argument is 0, subtract
‌ (U+200A) $arg 	Print 1st element on stack; If argument is 0, don't pop, else pop
 (U+2009) $arg 	Loop next instruction argument times
 (U+2008) $arg $arg2	If argument is equal to argument 2, run next instruction, else skip past instruction
== Examples ==
Sorry, there are no sample programs here.
== Categories ==
Category:Languages Category:Stack-based Category:No IO
0x29C

0x29C is a variation of 0x29A. The commands are different. Another difference is the way the register works. 
Commands:
* Push a function to the stack: Any of the commands _|,.+-$ push that function to the stack (_ = k, | = s).
* [x] creates a loop function containing x and pushes to stack. Loops can be nested.
* {x} do commands x with a new stack (empty) and register (zero), and then pushes copy of top value of old stack to top of new stack. At the end, it reverts to old stack and register, and pushes a copy of the top value of the new stack to the top of the old stack (the entire new stack and new register are destroyed). These can be nested.
* The % and ~ have the same function as 0x29A.
Pre-processor commands:
* &name(value) = Creates a macro. Include ? anywhere in the value to use the parameter given to the macro. The name can use any printable ASCII characters other than &'();/* and white-spaces.
* 'name(parameter) = Include a macro in the program.
* 'name; = An abbreviation for 'name().
* /* comment */ = A C-style comment.
Functions:
* _(k) |(s) , . + - are same as 0x29A
* (([x]y)z) = pop this function off of the stack, repeat commands in loop x until register is zero, and then push y to stack.
* (($x)y) = pop this function off of the stack, then push x to the stack, and then push y to the stack.
Register: (The register stores values 0 or 1 or 2 only)
* + changes 0 to 1, 1 to 0, 2 stays at 2.
* - changes 0 to 2, 2 to 1, 1 to 0.
* Input is done one bit at a time and the value is 0 or 1.
* Output is one bit at a time. Trying to output 2 has no effects.
Examples:
* Push identity function to stack = |_~|~
* Discard top entry of stack = %_%~%~
* Increment value of register = +%+%~%~
* Duplicate top entry of stack = |$~|_~|~~%~
* Set value of register to zero = [-%-%~%~]_~_~%_%~%~
* Another identity function to stack = {%}
Category:Languages
Category:Unimplemented
Category:2007