nyuuzyou/wikis huggingface dataset:
Underload/a interpreter in python

def run(p):
 stack=[]
 program=p
 while program:
 x,program=program[0],program[1:]
 if x=='*':b,a=stack.pop(),stack.pop();stack.append(a+b)
 if x=='^':program=stack.pop()+program
 if x=='~':a,b=stack.pop(),stack.pop();stack.append(a);stack.append(b)
 if x==':':stack.append(stack[-1])
 if x=='!':stack.pop()
 if x=='a':stack.append(f'({stack.pop()})')
 if x=='S':print(stack.pop(),end=)
 if x=='(':
 i=1;tmp=''
 while True:
 x,program=program[0],program[1:]
 if x=='(':i+=1
 if x==')':i-=1
 if i==0:break
 tmp+=x
 stack.append(tmp)
program=r'''
(
x y pair = (x y)
pair = ~a~a*
(x y) left = x
left = ^!
(x y) right = y
right = ^~!
)!
(
x y true^ = x
true = (!)
x y false^ = y
false = (~!)
c t f if = t f c^^
if = a(a(a)~(a))~(a(a*~(^^)**^)****^)**^
true not = false
false not = true
x not = false true x ^
not = a((~!)(!))~(^)**^
)!
(
zero = pair true () = ((!)())
zero isZero = true
non_zero isZero = false
isZero = left = ^!
x succ = pair false x = ((~!) x)
succ = a((~!))~*
zero pred = zero
non_zero pred = non_zero right
pred = a:((((!)()))~(^~!))~(a(^!^)****^)**^
)!
(
init cond step loop = init (init cond^ is false)
init cond step loop = init step^cond step loop (init cond^ is true)
loop = a(a(~:a)~(a(^)*~:(a)))~(a(a(a(^~:^)**(!))**~(a*a(a(a)~(a))~(a(a*~(^^)**^)****^)**^)****^)****:^)**^
x toUnary = (1...1) (repeat x times)
toUnary 
= ()pair(left isZero not)(λx.x left right x right (1)* pair)loop right
= ()~a~a*(^!^!a((~!)(!))~(^)**^)(:a(^!^~!)~(^~!(1)*~a~a*)**^)a(a(~:a)~(a(^)*~:(a)))~(a(a(a(^~:^)**(!))**~(a*a(a(a)~(a))~(a(a*~(^^)**^)****^)**^)****^)****:^)**^^~!
)!
((!)()) a((~!))~* a((~!))~* a((~!))~*
()~a~a*(^!^!a((~!)(!))~(^)**^)(:a(^!^~!)~(^~!(1)*~a~a*)**^)a(a(~:a)~(a(^)*~:(a)))~(a(a(a(^~:^)**(!))**~(a*a(a(a)~(a))~(a(a*~(^^)**^)****^)**^)****^)****:^)**^^~!
aS
'''
run(program) #(111)
Or if you want to run it online.
https://tio.run/##zVVLbtswEN3zFNRKHNkxInTHQKdIu6lhFrQtJ0IciZAVVGpRXax36JXcmSHlj5QU6aaoDdvD9@b/aNt1zWNVfrhxneuOx22@k/VLqRxoIfFxaOzmKVuu@ODq6qG2z5nj09fHYp8PmPemRzs/ufnP5e1qgJapXp0ci51ssyxOYr2e24wLLVzlFMwv7DtvW@fycqvsbA3jeBProeBF3CxgY@8@1na@fme10XlaW8f6yoMPy5t0NfGMBk@uM2btKM8uVt8v3H9APAm5p7GLslGXo2BsFk99VXyWh@EsvWueHbpewV7Qj/VLfu3@V6pOSxezLH2LBqRvXqeLLLvV6zq3TxMWe59l7RV8tT7kQQz91jGOqUQrO@lsUctMKrSR94fe9jYRDMl9vmsQakUwTBSIunh4JKATg2X6SEAU8ja4MsOBZFGFCJjY2f2BmU6wSVSP3EY2ckdDZmxsjBF8sAqf0OOL3pRNemUMJAm9/LvxJcqKmuCcIbNHiMTKFzRDspVGeNAq6gAbxAo@IY/xLa8rZHkpHKGAmkU/BeDZ4vDZO3GRsiq/XMO@m9PxvMNWHl42myG776rl7NiJbEEE2rcGfeLruTrfIkr2uVoAT2fWQwTUaqVCyzQdJ8M1muhyfzxuURaN3FTlFi9O7uS@qhzGM6pOnMHZfLvwpwACzIgaJaGNgQhBJHKvrW8Nkl6T3F5vQnpNfZJACcpvk3fciZOVJNoPiTtvqk@lrTvac7pYLFKQqs5dbhvcfVM85wcQg4tAHyBxFIsWJMT7AurXz3bRei391W/Dp0ohYUGBx/I6UB7@QtHOo8lVA6VZDURZHsrB7kz@g72Eb60Il@R8416zxP8/i70X9OvGf9j@5w6Ox98
by User:Jan jelo
Underload/a interpreter in scheme

This is a Underload interpreter in scheme by User:Jan jelo.
(define(init program)
 (list(string->list program)
 '()))
(define(program state)
 (list-ref state 0))
(define(stack state)
 (list-ref state 1))
;a
(define(a state)
 (list(cdr(program state))
 (cons(string-append "("
 (car(stack state))
 ")")
 (cdr(stack state)))))
;!
(define(!! state)
 (list(cdr(program state))
 (cdr(stack state))))
;*
(define(** state)
 (list(cdr(program state))
 (cons(string-append(cadr(stack state))
 (car(stack state)))
 (cdr(cdr(stack state))))))
;:
(define(:: state)
 (list(cdr(program state))
 (cons(car(stack state))
 (stack state))))
;~
(define(~~ state)
 (list(cdr(program state))
 (cons(cadr(stack state))
 (cons(car(stack state))
 (cdr(cdr(stack state)))))))
;^
(define(^^ state)
 (list(append(string->list(car(stack state)))
 (cdr(program state)))
 (cdr(stack state))))
;S
(define(S state)
 (display(car(stack state)))
 (list(cdr(program state))
 (cdr(stack state))))
;()
(define(bracket state)
 (define(find state i)
 (if(= i 0)
 (list(program state)
 (cons(substring(car(stack state))
 0
 (-(string-length(car(stack state)))1))
 (cdr(stack state))))
 (find(list(cdr(program state))
 (cons(string-append(car(stack state))
 (list->string(list(car(program state)))))
 (cdr(stack state))))
 (cond((equal? #\( (car(program state)))(+ i 1))
 ((equal? #\) (car(program state)))(- i 1))
 (#t i)))))
 (find(list(cdr(program state))
 (cons""(stack state)))
 1))
(define(step state)
 (define(op state)
 (car(program state)))
 ((cond
 ((equal?(op state)#\a)a)
 ((equal?(op state)#\!)!!)
 ((equal?(op state)#\:)::)
 ((equal?(op state)#\~)~~)
 ((equal?(op state)#\*)**)
 ((equal?(op state)#\^)^^)
 ((equal?(op state)#\S)S)
 ((equal?(op state)#\( )bracket))
 state))
(define(run p)
 (define(exec state)
 (if(equal? '()(program state))
 #f
 (exec(step state))))
 (exec(init p)))
(run "(:aSS):aSS")
;(:aSS):aSS
Understander

Understander is a programming language that uses "Understand text as concept" to do stuff
= What it does =
== Right now ==
The interpreter doesn't understand anything but understanding
== What you can use ==
Use "understand"
 Understand print <a> as <a>
 print hello world
Use more stuff
 Understand True <x> <y> as <x>
 Understand False <x> <y> as <y>
 Understand Not <x> as <x> False True
 Understand And <x> <y> as <x> <y> False
Undocumented

Undocumented is a programming language.
== Examples ==
=== Cat program ===
 %c^o9
Try it online
=== Invert bits ===
 !BPY`/
Try it online
=== Reverse bits ===
 u?|*r:X81Z2
Try it online
=== Hello, World! ===
 BaxJ=4qML(\(={pm<H/A4iR9UJaIh)(>Mvg3{1`;x%<hAE`0':{9lzc%+u#.IE.a2dl2pW0L!oO)sTG*F]mEmMtg)BHur@Ze'2&2
 #Y3mjz"-<f
Try it online
== Interpreters ==
Interpreter
Category:Languages
Category:Turing complete
Category:2021
Category:Implemented
Unfedern

2018
Category:Declarative_paradigm
Category:Object-oriented_paradigm
Unfedern is a derivative of Entfedern.
== Extensions ==
=== Anonymous Variables ===
The following example is impossible in Entfedern, but possible in Unfedern.
 Cat {
 finalize() {
 int c;
 c = read();
 1 = sign(c + 1);
 printed(c);
 finalized();
 }
 }
Syntax:
 <literal> = <expression>;
e.g. The left hand of this anonymous 'assert'-alike statement must be a string/integer/float... literal (compile/first-JIT time constant).
This statement is called the 'assert' statement.
=== Delayed declaration and definition ===
Variables can be declared anywhere in a function (but only with unique names).
 int x = 1; 
 printed(x);
 int y = x;
== Examples ==
=== cat ===
 Cat {
 finalize() {
 int c = read();
 1 = sign(c + 1);
 printed(c);
 finalized();
 }
 }
Unfuck

Unfuck is an esoteric programming language designed by User:Andrew_Melrose in 2015. The language is based on Urban Müller's Brainfuck language, but it takes a different spin on how control flow works. It has an infinite tape with 8 bit wrapping cells.
All instructions for the exception of [ and ] still remain. Instead a new set of instructions have been put in their place.
There is only one instruction which carries out a conditional test on the current cell, from that and it's complimentary instructions, a variety of control flow structures can be composed. Below is a list of those instructions and a description of what they do;
 ? Tests the current cell to determine if it is non-zero, if so, skip the next instruction.
 ( Increments the block depth counter.
 ) Decrements the block depth counter.
 ~ Swaps ( and ).
 ! Inverts the block depth counter.
 ^ Does the same as ~ and !, plus reverses the program counter.
These instructions work by manipulating the way the interpreter treats the rest of the program depending on the value held in the block depth counter. If the value is positive, then all of the instructions for the exception of the parenthesis will be treated as no-ops. With that said, the parenthesis can also be used to comment out code.
== Examples ==
So, how does one build a while loop?
 (^~)~(~?!)((
 Execute some code until condition is met
 ))(^)
Most often than not all we want to do is test a cell and execute some code once. Here is an if structure.
 ~(~?!)((
 Some code to execute once.
 ))(!)
These are just two out of a dozen or more structures that can be built. It is left as an excercise for the reader to discover the rest.
It is good practice to only place standard Brainfuck code when the block depth is zero, rather than when it is negative. This may become an important rule in a future implementation.
== Computational class ==
Unfuck is Turing complete by reduction to Brainfuck.
 [ = (^~)~(~?!)((
 ] = ))(^)
== External Resources ==
* Github page, and Python implementation
Category:Languages
Category:Brainfuck derivatives
Unhaltingfuck

UnHaltingFuck is a language very much like Brainfuck, with one key difference: instead of loops stopping when the value in the current cell is zero, they stop when the value in the current cell is the Gödel number of an UnHaltingFuck program that doesn't halt. The specific Gödel encoding is not specified since it doesn't affect any interesting properties of the language.
==Computational Class==
UnHaltingFuck is uncomputable. This can be shown as follows:
* There exists an UnHaltingFuck program that halts (for instance, the empty program)
* There exists an UnHaltingFuck program that doesn't halt (for instance, if the program encoded by the Gödel number 0 is the empty program, [])
* Consider the subset of UnHaltingFuck programs in which cells take only one of two values, which are the Gödel numbers of those two programs. That is, whenever a + or - is used it is immediately followed by enough +s or -s to bring the value in the current cell to one of those values. This language can be trivially translated to and from Boolfuck, which is known to be Turing-Complete.
* Since there exists a Turing-Complete subset of UnHaltingFuck, the question of whether an UnHaltingFuck loop runs or not is uncomputable in general.
==HaltingFuck==
UnHaltingFuck implies a sister language, Haltingfuck, whose loops stop when the value in the current cell is the Gödel number of a HaltingFuck program that halts. The specification of this language is incomplete - ie. it has interpretations that are consistent, but more than one interpretation fits the specification.
Category: Languages
Category: Brainfuck derivatives
Category: 2021
Category: Uncomputable
Category: Cell-based
Unhappy

==Commands==
* a~z : variables. They should be inputted in console. When they are inputted, it prints itself every time it is called.
* A~Z : define a function when ; is not met. When they are called twice, the program will run the function.
* % : make a Brainfuck interpreter.
* > : call the class and call the function.
* 0~9 : Define a class until ; is met.
* ; : end a class or a function.
* : : separate a class or function from code.
==Examples==
Hello,world!
 0:A:a;;
 0>A
This only works when input is "Hello,world".
Category:Languages
Category:Turing tarpits
Category:Object-oriented paradigm
Category:2018
UniCode

UniCode is an esoteric programming language where every character in unicode is one instruction, and therefore anything is valid UniCode syntax, even if it causes run-time errors. One issue, because of this, is the inability to have comments directly in UniCode programs.
The original pages about UniCode are available at revision 11144 (the original page created in 2008) and revision 18209 (a minor fix after two years). However, this language has been stuck on "Work In Progress" for four years before User:NSQX thought that it has been a "Work In Progress" for too long and rewrote this page.
UniCode symbol	Unicode decimal value	Unicode escape identifier	Meaning as UniCode instruction
I 	73 	 	Input as ASCII
O 	79 	 	Output as ASCII
« 	171 	 	Left shift the memory value under the pointer by 1
» 	187 	 	Right shift the memory value under the pointer by 1
Ì 	204 	 	Input as ANSI
Ø 	216 	 	Output as ANSI
← 	8592 	 	Decrement the pointer
↑ 	8593 	 	Increment the memory value under the pointer
→ 	8594 	 	Increment the pointer
↓ 	8595 	 	Decrement the memory value under the pointer
↔ 	8596 	 	Swap the memory value under the pointer and the clipboard value
↩ 	8617 	 	Output as Unicode
↪ 	8618 	 	Input as Unicode
↱ 	8625 	 	Skip (clipboard value) commands if the memory value under the pointer is not 0
↳ 	8627 	 	Skip (clipboard value) commands if the memory value under the pointer is 0
↶ 	8630 	 	Cut the memory value under the pointer to the clipboard value
↷ 	8631 	 	Paste the clipboard value onto the memory value under the pointer
↸ 	8632 	 	Copy the memory value under the pointer to the clipboard value
↹ 	8633 	 	Exit with the memory value under the pointer as the code
⇇ 	8647 	 	Output as decimal
⇈ 	8648 	 	Output as hexadecimal
⇉ 	8649 	 	Input as decimal
⇊ 	8650 	 	Input as hexadecimal
⇐ 	8656 	 	Change the execution direction to left
⇑ 	8657 	 	Change the execution direction to up
⇒ 	8658 	 	Change the execution direction to right (default)
⇓ 	8659 	 	Change the execution direction to down
⇖ 	8662 	 	Change the execution direction to upleft
⇗ 	8663 	 	Change the execution direction to upright
⇘ 	8664 	 	Change the execution direction to downright
⇙ 	8665 	 	Change the execution direction to down left
Category:Languages
Category:Unimplemented
Category:2012
Category:Two-dimensional languages
Unicat

Unicat is an esoteric programming language created in 2015 by User:Gemdude46.
The language is programmed using the 9 cat emoji: ( 😸 😹 😺 😻 😼 😽 😾 😿 🙀 )
All other characters are ignored.
Memory is an infinite tape of signed bignums.
A Unicat interpreter, as well as examples, can be found on Github.
Hello, world! is as follows:
 😻😹😸🙀🙀😹😹😸🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😼😽🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😽😼🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😽😼🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😽😿🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😽😼🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😼😸🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😺😿🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😽😿🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😾😺🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😽😼🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😼😼🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😼😹🙀🙀😽😼😸🙀🙀😻😹😸🙀🙀😹😺🙀🙀😽😼😸🙀🙀🙀🙀
A full documentation is yet to be written.
Any string is a valid Unicat program, although most will loop forever.
Category:Languages
Category:Implemented
Category:2015
Unicode

Unicode is a mapping of positive integers (called 'codepoints') onto characters, like ASCII which is supersedes. Unlike ASCII, it is not an binary encoding, but several common ones, notably UTF-8, are used to encode Unicode codepoints in binary. UTF-8 actually includes ASCII as its first 128 characters for backwards compatibility.
== See Also ==
* Unicode on Wikipedia
* ASCII
* LSCEF
* Uniсode, a page for everything unicode-related
Category:Concepts
Unicorn

Unicorn is a very simple programming language. You can learn the basics of coding without needing special software. Everything is on this webpage, including this tutorial. The tutorial is split into chapters which describe the different parts of the language, give examples, and exercises for you to try. The chapters may include Deep Thoughts. These are optional as far as learning the language is concerned, but may help you understand more about computers and programs.
==External resources==
* 
Category:Languages
Unified HQ9+

Unified HQ9+, or alternatively, HQ9+++-*TCIX13BG2DidcoshwNZLEAR7U, is a language made by User:Cortex to unify all HQ9+ variants. It includes commands from just about every HQ9+ variant I could find, as well as some commands from other languages, and a few new commands unique to Unified HQ9+. Characters that are not commands are ignored.
== Commands ==
Character	What it does 	Language it's from
H 	Print "Hello, World!" 	HQ9+
Q 	Print the program's source code 	HQ9+
9 	Print the lyrics to 99 bottles of beer 	HQ9+
+ 	Increment the accumulator 	HQ9+
++ 	Create a new object and increment the accumulator twice. 	HQ9++
- 	Decrement the accumulator 	New to Unified HQ9+
* 	Double the accumulator 	New
T 	Change the instruction set to a Turing-complete superset 	HQ9+T (mentioned in CLB's HQ9+ blog post)
C 	Copy input to output 	CHIQRSX9+
I 	Interpret input as Unified HQ9+ code 	CHIQRSX9+
X 	Make the language Turing-complete 	CHIQRSX9+
1 	Interpret all characters in the rest of the source code as their ROT13 variant. 	CHIQRSX9+
3 	Nop, for convenience. 	New
B 	Interpret input as a brainfuck program 	HQ9+B
G 	Print the interpreter's source code. (I is already taken, so I used G) 	HI9+
2 	Increment the accumulator twice (for if you don't want to print ++'s explanation) 	New
D 	Make the language 2D, and add all commands from HQ9+2D 	New, but added to support HQ9+2D
i 	Increment the accumulator. If the accumulator is a character, set it the next ASCII character. 	Deadfish~
d 	Decrement the accumulator 	Deadfish~
c 	Make the accumulator a character 	Deadfish~
o 	Print the accumulator 	Deadfish~
s 	Square the accumulator 	Deadfish~
h 	End the program (it's necessary now, because of course it is) 	Deadfish~
w 	Print "Hello, world!" 	Deadfish~
N 	Increment the accumulator by 10 	New
Z 	Set the accumulator to 0 (or to ASCII character 0 if the accumulator is a character) 	New
L 	Blink LED (compilers and interpreters need not implement this command if they so choose) 	Embedded HQ9+
E 	Print a link to this very Esolangs article. 	Hexlr7
A 	Print the name of the programming language the interpreter was written in. 	Hexlr7
R 	Make the interpreter throw an error. 	Hexlr7
7 	Do the following command 7 times. 77 followed by a command will do it 49 times. Any more than that and it just does it 7 times.	Hexlr7
U 	Do whatever the creator of the interpreter wants this command to do 	New
== Examples ==
=== Hello, World! ===
Hh
 (prints "Hello, World!")
or
wh
 (prints "Hello, world!")
or
NN*NNN2coZNs+oN---oo2+oZ2ss-N2oZ2ss-o-NN2+oN22o2+o------oZNsoZ2ss*+h
 (prints "Hello, World!")
=== 99 bottles of beer ===
9h
=== Quine ===
Qh
=== Cat program ===
Ch
=== Brainfuck interpreter ===
Bh
=== Self-interpreter ===
Ih
=== Hello, World! except it's 2D now for some reason ===
D vh <
 v H <
 > ^
 > ^
=== Hello World 2D, Part 2 ===
Dv
>Hh
^<
==External resources==
* A partial interpreter by User:CatCatDeluxe
Category:Joke languages Category:Unimplemented Category:Languages Category:2019 Category:Turing complete Category:Usability unknown
Unilot

Unilot is a programming language originally conceived by user:Lukalot and heavily influenced by user:Heavpoot, user:LyricLy, and user:Galaxtone, becoming Lukalot’s first esolang. The concept was that any number more than 1 cannot be added or subtracted from a variable, unless that number is stored within another variable. Variables are 1 character long and are always integers. There is one input and one output.
==Overwiew==
Unilot operates through variables, each initially set to zero. Variables can be incremented or decremented by 1, or more if the effecting number is stored within a variable. Unless the command is literally [ or ], things surrounded in [] are optional. The commands are:
 +<variable>[<variable>] Adds one to the following variable, or adds the second variable to the first variable if there is a second argument.
 -<variable>[<variable>] Subtracts one from the following variable, or subtracts the second variable to the first variable if there is a second argument.
 <<variable><variable>[<inverse>] Decrease the first variable by one if the first and second variable are equal. Conditions are inversed if <inverse> is equal to “!”.
 ><variable><variable>[<inverse>] Increase the first variable by one if the first and second variable are equal. Conditions are inversed if <inverse> is equal to “!”.
 {<variable><variable>[<inverse>] Same as previous conditionals, but jumps backwards 2 lines when conditions are met.
 }<variable><variable>[<inverse>] Same as previous conditionals, but jumps forwards 2 lines when conditions are met.
 [<distancevariable> Jumps backwards <distancevariable> lines.
 ]<distancevariable> Jumps forwards <distancevariable> lines.
 @<variable> Outputs <variable> from ASCII code.
 . Ends the program loop.
To reference the input, use *.
==Examples==
*Hello world:
 +a +a +ia +ji +j +aa +fa +aa +ha +aa +ga +aa +aa +a +bh +ab -a @a +cg +cc -ab +a +ac +af @a +af +aj @a @a +aj @a +bb +bb +dg +db -df @d @b +eh +ae @a -ae @a +ai +a @a -af -ai @a -ae @a +b @b .
*Quine:
 No quine written yet.
Category:Languages Category:Unimplemented Category:2018 Category:Unknown computational class
Union

Union(/ˈʌnjən/) is a unique concentrative language that is based on queues, not stacks or deques(which can simulate stacks) invented by User:A. It is mainly influenced by the union find algorithm(which involves trees). The restriction on queues have increased its difficulty of programming. It is hard to evaluate an expression that does what the user wants. It was presumably the first esoteric programming language that is based on trees.
== Commands (just like any other concentrative language) ==
front: Push the front of the queue to the back of the queue
x or y: This pushes x or y onto the queue depending on what is specified.
x y union: Pop 2 values from the queue, and add x as y's father in a tree.
x find: Find the father of x and push that value onto the queue
x y setfather: Clear all of x fathers and set y as x father in a tree.
x swap: Swap x with x's father inside a tree.
x if y end: Pop x from the queue. If x is nonzero, execute y inside an if statement(where y is a list of instructions)
x loop y end: Pop x. If x is nonzero, execute y inside a while loop(where y is a list of instructions) until the front item becomes 0. (Of course, after y is executed)
x y equal: Push 1 onto the queue is x and y are equal; otherwise, push 0.
add, sub, mul, div: Do the corresponding mathematical operations.
== Examples ==
=== Evaluate 1-(3/2) ===
3 2 div 1 front sub
=== Exchange two values inside a tree (make sure you know the values )===
Swap 1 and 2 under a same father.
1 swap 2 swap 1 swap
=== Infinite loop ===
1 loop 1 end
=== Looping counter ===
1 4 setfather 1 loop if end 4 find 1 add 4 setfather 1 end
=== Hello, world! program doing no output ===
This creates numbers and makes them fathers of themselves (which is similar to outputting them). However, trees cannot repeat, so this does not print the right string...
72 72 union 101 101 union 108 108 union 111 111 union 44 44 union 32 32 union 87 87 union 114 114 union 100 100 union 33 33 union 10 10 union
=== Union find algorithm ===
This puts the result into the father of 9999.
The first line is input; the second line is the process.
1 2 union 1 3 union 2 4 union 5 4 union
1 loop 5 find setfather 9999 5 find 5 equal 0 1 sub mul 1 add end
== Computational class ==
Its computational class is still in question, due to the special syntax.
Category:Languages
Category:Queue-based
Category:Tree-based
Category:2019
Category:Unimplemented
Category:No IO
Category:Unknown computational class