nyuuzyou/wikis huggingface dataset:
Cyclic tag system

A cyclic tag system is a Turing-complete computational model in which a binary string of finite but unbounded length evolves under the action of production rules applied in cyclic order.
==Definition==
A cyclic tag system is a finite list of finite binary strings (called productions), P0,P1,...,Pn-1, together with a finite binary data-string D. The data-string evolves from a specified initial string by iterating the following transformation, halting when D is empty:
 (i, dX) → (i+1 mod n, XPid)
where i is a pointer (initially 0) to the current production, dX denotes the data-string D with leftmost symbol d (0 or 1). Here Pi0 denotes the empty string, and Pi1 = Pi. 
In other words, the productions are considered one at a time in cyclic order, appending the current production to the data-string if the latter begins with 1, then deleting that first symbol (each time in any case).
==Example==
Productions: (011, 10, 101) 
Initial data-string: 1
System evolution:
Production	Data-string
 011 
 10 
 101 
 011 
 10 
 101 
 011 
 ...	
 1
 011
 11
 1101
 101011
 0101110
 101110
 ...
==History==
The cyclic tag system model is a modified form of tag system, designed to allow control of the order of application of the production rules. By encoding a tag system's alphabet as equal-length binary strings, a cyclic tag system can be designed to emulate any tag system -- thus showing the latter to be Turing-complete (since the set of tag systems is Turing-complete). Matthew Cook relied on cyclic tag systems to prove the Turing completeness of Stephen Wolfram's Rule 110 cellular automaton.
==Computational class==
Cyclic tag systems are Turing-complete. As noted above, this was first proved via tag systems.
If you like Fractran, you may find this reduction via Collatz functions simpler, not to mention easier to track down.
==Related articles==
* Tag system
* Sequential tag system
* Bitwise Cyclic Tag -- a Turing tarpit derived from cyclic tag.
* BIX Queue Subset #Existing languages
== External resources ==
* Compiler from Turing machines to cyclic tag written in Wolfram Mathematica (by User:Xylochoron)
* A cyclic tag interpreter written in Jelly and runnable online
Category: Computational models
Cyclifford

Cyclifford is a silly idea of a language by User:arseniiv, based on Clifford algebras.
The program is an expression consisting of integer literals, variables, additions, subtractions, multiplications and applications of two non-principal (anti)automorphisms. Variables v_i are referenced by their positive integer indices i\in\{1, \ldots, N\}.
At runtime, the input is treated as a desctiption of a Clifford algebra (over integers): its length in bits is the generator count, and for each generator v_i^2 is taken to be +1 when the i-th bit is 0, and −1 when that bit is 1. The state of computation S initially is taken to be the program. Then the Procedure A is applied to S until it’s self-conjugate, i. e. applying principal automorphism to S returns S itself.
Procedure A is as follows. In S, replace each v_i with v_{i+1} treating indices modulo the input length, and name the result T. Then assign S := ST.
If the computation halts, the output is the scalar (grade-0) part of the final S.
== Example of operation ==
I’m fairly confident no one understood anything above so an example will come soon. Or will it?..
Category:2019
Category:Usability unknown
Category:Unknown computational class
Category:No IO
Category:Unimplemented
Czure

Czure (pronounced as "seizure") is an esoteric programming language made by User:Marina. It is an equivalent to C, but every time you run a program there's a 96.217503% chance that it crashes.
==Example programs==
===Hello World===
#include <stdio.h>
int main(void) {
 printf("hello silly world");
}
This program will most likely crash with a small chance that it prints "hello silly world".
Category:Languages
Category:Joke languages
Category:2023
Category:Turing complete
C±±

An esoteric language created by User:SoYouWantMeToDoSomethingButIWont that
has only 1 operation: NAND
== Syntax ==
The program is divided into "functions" that are denoted like so:
 name { code }
The language automatically calculated needed amount of arguments.
An expression can be one of the following:
Name 	Syntax 	Info 	Meaning
NAND Gate 	'.' a b	a and b are expressions 	Calculates NAND of a and b
Argument 	x 	x is a lower-case english letter 	Becomes a value passed to the function.
Operation 	o a... 	o is a punctuation symbol, a... are N expressions that o requires	Calls the function with N arguments
Assignment	'=' K v	K is a upper-case english letter and v is an expression 	Creates a local binding
Binding 	X 	X is an upper-case english letter 	Value of a local binding
Chain 	a ';' b	a and b are expressions 	Calculates both, but returns the latter
Tuple 	a ',' b	a and b are expressions 	Creates a tuple of a and b
Selector 	n a 	n is an integer and a is an expression 	Returns the nth element of tuple a
Comments span from // to the end of a line
== Program ==
At the start, the last function defined is called and the user
is prompted with the arguments required to calculate the function
and then the result is outputted. 
== Example ==
~{.aa} // Not
&{~.ab} // And
|{.~a~b} // Or
^{..a~a.b~b} // Xor
/{&ab,^ab} // Half-Adder
+{=C/ab;=D/0Cc;0D,|1D1C} // Full 1-bit Adder
== TODO ==
== Implementations ==
Currently, there are none.
Category:Languages Category:Unimplemented
C²

Simple low-level assembly-like programming language that focuses on being easy to "parse"
Example:
 label _start:
 othervar: charget
 othervar+1: charget
 othervar+2: charget
 othervar: atoi 3 ; 3 bytes string (3 chars)
 myvar: set 3
 myvar: add 9
 myvar: add othervar
 myvar: itoa 2 3 ; 2 byte integer (16 bit) to 3 chars
 myvar: outchar
 myvar+1: outchar
 myvar+2: outchar
 
 var myvar [3]u8 ; 3 byte array
 var othervar [3]u8 ; 3 byte array
Example with macros (redefines the add macro defined in the stdlib):
 macro (var pt->u8compatible) add (val imm=u8compatible):
 #switch arch
 #=bf @raw "$*var*$*times val char +*$:*val*$"
 #=x86 @raw "add $*var*$, *val*" 
 #=ezbrain @raw "do $*var*$ byteOp 0 add *val*"
 #else
 #- @error "inc macro does not support architecture"
 
 label _start:
 myvar: add 3
 
 var myvar u8
Category:LanguagesCategory:UnimplementedCategory:Low-level
C̬̤̬͔̮̺̋̄̄̂̓̀ͧ̐h̺͋ͧ̓̏̄͂̉̓ͦa͔̬ͫ̎ͭ̃̃͊̊ì̜͔̼͓̰̱͍͈̰̊̉͒ň̤̃ͩ̒͜͜͞f̪̲̖̏ͨ̈͋̃̚a̴̪̮ͧ̓ͣ̈́̇̐ͯ̍̚ļ̴̜̘̥̱ͪͣ̅́ͭͣ́ļ̡̱̓ͩ̄̒̾̎̊͊́

:The blank space below this notice prevents Zalgo interference.
C̬̤̬͔̮̺̋̄̄̂̓̀ͧ̐h̺͋ͧ̓̏̄͂̉̓ͦa͔̬ͫ̎ͭ̃̃͊̊ì̜͔̼͓̰̱͍͈̰̊̉͒ň̤̃ͩ̒͜͜͞f̪̲̖̏ͨ̈͋̃̚a̴̪̮ͧ̓ͣ̈́̇̐ͯ̍̚ļ̴̜̘̥̱ͪͣ̅́ͭͣ́ļ̡̱̓ͩ̄̒̾̎̊͊́
C̬̤̬͔̮̺̋̄̄̂̓̀ͧ̐h̺͋ͧ̓̏̄͂̉̓ͦa͔̬ͫ̎ͭ̃̃͊̊ì̜͔̼͓̰̱͍͈̰̊̉͒ň̤̃ͩ̒͜͜͞f̪̲̖̏ͨ̈͋̃̚a̴̪̮ͧ̓ͣ̈́̇̐ͯ̍̚ļ̴̜̘̥̱ͪͣ̅́ͭͣ́ļ̡̱̓ͩ̄̒̾̎̊͊́ is a language in progress by user:david.werecat where each letter is a context to chains of subscript and superscript characters. Each chain represents a subfunction. At each letter, zero or more chains are executed based on the completed context.
To any interested parties, the title reads "Chainfall".
== Characters ==
Going up (superscript)
̍ 	̎ 	̄ 	̅ 	̿ 	̑ 	̆ 	̐ 	͒ 	͗
͑ 	̇ 	̈ 	̊ 	͂ 	̓ 	̈́ 	͊ 	͋ 	͌
̃ 	̂ 	̌ 	͐ 	̀ 	́ 	̋ 	̏ 	̒ 	̓
̔ 	̽ 	̉ 	ͣ 	ͤ 	ͥ 	ͦ 	ͧ 	ͨ 	ͩ
ͪ 	ͫ 	ͬ 	ͭ 	ͮ 	ͯ 	̾ 	͛ 	͆ 	̚
Going in the middle
̕ 	̛ 	̀ 	́ 	͘ 	̡ 	̢ 	̧ 	̨ 	̴
̵ 	̶ 	͏ 	͜ 	͝ 	͞ 	͟ 	͠ 	͢ 	̸
̷ 	͡ 	҉
Going down
̖ 	̗ 	̘ 	̙ 	̜ 	̝ 	̞ 	̟ 	̠ 	̤
̥ 	̦ 	̩ 	̪ 	̫ 	̬ 	̭ 	̮ 	̯ 	̰
̱ 	̲ 	̳ 	̹ 	̺ 	̻ 	̼ 	ͅ 	͇ 	͈
͉ 	͍ 	͎ 	͓ 	͔ 	͕ 	͖ 	͙ 	͚ 	̣
Category:2013
Category:Languages
Category:Thematic
Category:Unimplemented
D

:Not to be confused with the non-esoteric language D.
D is an esolang made by User:Yes
== Commands ==
Header text	Header text
+ 	bf equivalent but has 14% chance to fail
- 	bf equivalent but has 14% chance to fail
, 	bf equivalent but has 14% chance to fail
. 	bf equivalent but has 14% chance to fail
< 	bf equivalent but has 14% chance to fail
> 	bf equivalent but has 14% chance to fail
[ 	bf equivalent but has 14% chance to fail itself and all iterations of [ and ]
] 	bf equivalent but has 14% chance to fail itself and all iterations of ] and [
Destroy 	Destroy the program
All commands that aren't listed are ignored
=== Undocumented Commands ===
These are "security commands" which are called "undocumented commands" for no reason.
 Caption text
Header text	Header text
S 	Run the program through SHA-256 encryption and output the hash
E 	Get input and run it through SHA-256 encryption and output the hash
Note that the S command also considers comments and itself apart of the program, unlike everything else. The S and E commands are case sensitive by the way.
== Examples ==
Terminate program
Destroy
Encrypt input with SHA-256 and print the hash
E
Encrypt the word “Senile" with SHA-256 and print the hash
Senile
Category:Languages
Category:Brainfuck derivatives
Category:Probabilistic
Category:Cell-based
Category:Unimplemented
D'ni

==Overview==
This is an attempt, started by Eric James Parfitt, to slowly turn all of the English language into computer code, working in the direction of predicate logic. It is inspired by the idea that definitions can be broken down into as few as around 60 base words called semantic primes. It loosely follows and has used as inspiration Learn These Words First, a website which builds final link in a non-circular dictionary between all words in the English language and semantic primes at the bottom.
The name is inspired by a fictional language from a game called Myst, in which people called the D'ni write descriptions of worlds in a language called D'ni and can then visit the places they describe. This language was made with the idea in mind that some day one could write something like on(house, hill) and have a house drawn on a hill on the screen for example. It was also made with the idea that one could click on a word and watch it expand out down to something like semantic primes. The author has plans to perhaps implement a language already developed to be a logical language, such as Lojban.
==Implementation==
This page has all of the definitions so far. The definitions are currently written in Mathematica. They are a work in progress. Open source parsers of Mathematica do exist at this time however they are somewhat limited. The author of the language does have plans to possibly implement the language in a different language than Mathematica in the future. Here is some example code from the linked implementation:
moved[object_, destination_, origin_] := after[inside[object, origin], inside[object, destination]]
capableOf[thing_, action_, condition_] := if[condition, action[thing]]
closer[thingA_, thingB_, thingC_] := distance[thingA, thingC] < distance[thingB, thingC]
happen[verb_, condition_] := stateWhen[condition, verb]
likeWay[thingA_, thingB_, similarity_] := similarity[thingA] && similarity[thingB]
part[part_, whole_] := inside[part, whole]
caused[agent_, action_, method_] := method[agent] && after[agent, action] && implied[not[agent], not[action]]
........
pressChanged[presser_, pressee_, degree_] := becauseOf[pushed, presser, pressee, changed[shape[pressee], degree]]
soft[x_, softness_] := exists[presser, possible[presschanged[presser, x, softness]]]
fibre[x_] := tangle[x, string]
cloth[x_, softness_, underCondition_] := soft[x, softness] && exists[fiberA, madeOf[x, fiberA]] && capableOf[x, drape, underCondition]
bread[x_, seeds_, solidNess_] := exists[waterA, madeOf[x, mixed[seeds, water[waterA]]]] && solid[x, solidNess]
airborne[x_] := not[currently[fell][x]]
flew[x_, speed_, relativeTo_] := airborne[x] && moved[x, speed, relativeTo]
== External resources ==
* Blog post by originator with more details and links
* Github page
* "Lern These Words First," a non-circular dictionary used for inspiration
Category:Languages
Category:Declarative paradigm
Category:2018
D--

D-- is a cool language so someone make minecraft in it.
Command List:
PIZZA
Functionality: Draws a rectangle on the canvas.
Syntax: PIZZA x y width height
BURGER
Functionality: Gets user input and stores it in a variable.
Syntax: BURGER
SALAD
Functionality: Displays a message.
Syntax: SALAD message
SUSHI
Functionality: Conditional check based on user input.
Syntax: SUSHI condition code_block
Note: Supports conditional execution of code_block if the condition matches the stored user input.
TACOS
Functionality: Sets a variable value.
Syntax: TACOS var_name value input_type
Supported input types: 'TEXT' or 'NUM'.
STEAK
Functionality: Checks variable value and executes code block if matched.
Syntax: STEAK var_name var_type condition code_block
Supported variable types: 'TEXT' or 'NUM'.
RAMEN
Functionality: Adds a value to a numeric variable.
Syntax: RAMEN var_name add
SANDWICH
Functionality: Creates a label for code jumping.
Syntax: SANDWICH label_name
CURRY
Functionality: Jumps execution to a labeled block.
Syntax: CURRY label_name
KFC
Functionality: Clears the canvas.
Syntax: KFC
Syntax Notes:
code_block: Represents a series of commands separated by commas (,).
Variables: Identified by a preceding $ symbol in the syntax.
Download: Here
Category:Languages Category:Implemented
D.U.C.K.

D.U.C.K. (an acronym that will have meaning in the future) is an esoteric programming language created by User:SoundOfScripting that is designed to be used by time travellers. It apparently was/will be created sometime during the century beginning with the last year of the 3rd millennium CE.
==Syntax==
Coming soon!Most can be inferred from the examples.
==Example programs==
===Time Traveling Cat===
 0: D.U.C.K.wait(1);					//Wait 1 second
 1: x = input();						//Get input
 2: D.U.C.K.send(0);					//Go back to the start of the program
 3: output(x);						//Output the input
The above program outputs a value from input one second before the value is inputted (which is at the start of the program).
If the time traveller, after reading the output, attempts to input a different number, D.U.C.K. will go back in time again to receive another input. This will continue until the time traveller (keeping his/her memories of past inputs) gets bored and manually terminates the program (the escape key exits it).
Recent attempts at programming a bot to always input something that is not the output (as long as the bot is too fast for anybody to stop it) have resulted in D.U.C.K. temporarily opening a black hole, swallowing the device running the program, the device running the bot, and the time traveller. This does not appear to be avoidable.
===Unexecutable Program===
 0: D.U.C.K.send(-1);
The above program terminates one second before it is run. Similar problems resulting in black holes have occurred when attempting to execute the program infinitely after it terminates.
===Create the Universe===
 0: x = input();						//
 1: y += 99999999999999999999999999999;			//Builds up an infinitely large number
 2: if(x == "") D.U.C.K.goto(0);				//
 3: D.U.C.K.send(-y);					//Travels back in time that many seconds
 4: output("Hello, World!");				//Greet the newly created universe
This program attempts to send the user infinitely far back in time by generating an infinite number (y). However, it is impossible for a human to accomplish this without a bot; even the most patient time travellers will eventually force-terminate the program or send themselves far back in time. If a bot is used, the devices and time traveller disappear.
===Visit the Dinosaurs===
 0: D.U.C.K.send_abs(-235997984 * 31557600);		//Negative = BCE, Positive = CE (in most implementations). Time is approximate.
 1: x = input();						//Waits as long as the user wants
 2: D.U.C.K.send(0);					//Returns to the present time
Note: The above program should only be used on mobile devices with sufficient battery life. It is suspected that being eaten by a dinosaur will kill you.
Also note: This program assumes you are on Earth.
===(Probably) Witness Your Species' Extinction===
 0: D.U.C.K.send(31557600);				//One year into the future
 1: x = input();						//Wait
 2: D.U.C.K.send(0);					//Return
==See also==
* TwoDucks
Category:Languages
Category:Unimplemented
Category:Unknown computational class
Category:Unknown year
D1ffe7e45e

d1ffe7e45e is an esoteric programming language designed by User:Madk. Execution of commands is based on the numerical difference between the current hexadecimal number and the previous. This makes loops tricky but not at all impossible. Its command set is an expansion of brainfuck.
==Commands==
The first command of the program executed is assumed to be preceded by a 0.
 ## numerical difference between current command and previous
 ------------------------------------------------------------
 00 move memory pointer left
 01 move memory pointer right
 02 increment the cell under the memory pointer
 03 decrement the cell under the memory pointer
 04 take a number as input and store the value in this memory cell
 05 output this memory cell as a value
 06 output this memory cell as a character
 07 [
 08 ]
 09 rotate the bits of the cell under the memory pointer left once (do this 7 times to rotate right once)
 10 jump forward eight instructions
 11 jump backward eight instructions
 12 reverse program flow
 13 also [
 14 also ]
 15 nop
 / begin/end comment
Two nops in a row terminate the program. When the end of a program's code is reached it does not terminate, rather it wraps back to the beginning.
==Examples==
Equivalent of brainfuck [-]
 745666e
Translates to:
 [->><<]
Cat-like program (outputs the character for a given character code):
 4a86420
Translates (roughly) to:
 ,.+++++
==Computational class==
Although d1ffe7e45e has all the commands that brainfuck does, the language may or may not be able to achieve an Arbitrary effect at an arbitrary point so it is difficult to determine whether or not it is Turing-complete. However, the author speculates that moving the memory pointer left and back right repeatedly or incrementing and decrementing the current cell repeatedly (and therefore changing the current command number without any effect on the program's state) addresses this issue.
==External resources==
* Download d1ffe7e45e interpreter
Category:Languages
Category:Cell-based
Category:Implemented
Category:Brainfuck derivatives
Category:2011
DAEANAAACP

DAEANAAACP, short for Definitely An Esolang And Not An Arts And Crafts Project is an esolang created by User:PoptartPlungerBoi in 2024. The esolang uses paper and art materials to write code.
== Commands ==
Arrow = Start
Tape on paper = Print
Glue on paper = Input
Question mark = If
Red = 0 in binary
Green = 1 in binary
Text in circle = Comment
Down arrow = Linefeed
Cross = Stop
== Hello world ==
Category:Non-textual Category:Languages Category:2024
DBFV!

DBFV! is an esoteric programming language by User:David.werecat where each line of code is a separate function.
==Instructions==
Instruction	Description
x:[] 	Defines a loop for x not zero
x:() 	Defines a loop for x is zero
x<n 	Sets x to equal n
x> 	Outputs the ascii value of x
!n 	Jumps to function n
~n 	Calls function n
^ 	Returns from a call
x+ 	Increments x
x- 	Decrements x
>x 	Reads a value and stores in x
x% 	Skips the next instruction if x not zero
x& 	Skips the next instruction if x is zero
+n 	Skips n characters ahead in the line
x|n 	Swaps the values in x and n
.x 	Sets x to zero
*xn 	Adds n to x
$n 	Ends the program and returns n
n/ 	Pushes n into stack 1
/x 	Pops stack 1 and puts in x
n\ 	Pushes n into stack 2
\x 	Pops stack 2 and puts in x
@text@ 	Defines a comment
In the examples, x and n are registers. Registers are defined as A-Z (uppercase) and store a single wrapping byte of data. n can also be an immediate constant, which is a number from 0-9.
Whenever the instruction to be skipped is a loop, the entire loop is skipped.
==Computational class==
The following translation rules from Brainfuck show that DBFV! is Turing-complete.
brainfuck	DBFV!
begin 	0\.X
> 	X/\E+E0\0\\X
< 	X\4\/X
+ 	X+
- 	X-
. 	X>
, 	>X
[ 	X:[
] 	]
end 	$0
==External resources==
* Visual Basic .NET interpreter and sample programs
Category:Languages
Category:2012
Category:Turing complete
Category:Implemented
Category:Stack-based
DBR

DBR(Drawing BRainfuck), it's brainfuck like language, where instead of text files are the images and text commands instead of colored pixels.
== Commands colors ==
RGB code 	Brainfuck
127127127	>
18512287 	<
6372204 	+
2372836 	-
16373164 	no it's add 10 to current cell value
200191231	no it's subract 10 to current cell value
136021 	no output current cell value as number
25512739 	.
2552420 	no sets current cell value to 0
112146190	no stops program
195195195	no puts current cell number into current cell
== Hello, world! ==
Original size
== External resources ==
* http://rdml-markup.netai.net/dbr/ (online interpreter)
Category:Implemented
Category:Languages
Category:2016
Category:Brainfuck
DCI

DCI (Decrement then Copy [if successful]) is an OISC.
==Specifications==
*address 0 is always 1.
*IP is mapped to 1.
*the commands are memory mapped from addresses 2 to infinity. the values beyond the commands are initially 1.
**IP=0 means address 2, etc.
*decrementing IP when it's 0 will halt the program, which runs in an infinite loop.
==The operation==
The operation DCI, takes 4 arguments a,b,c and d.
C pseudocode is:if(*a>0){--*a;if(b)*c=b;else *c=*d;}*((int*)1)+=4;/*4 arguments as a command*/
==Examples==
Infinite loop
 10 2 10 0
 10 0 1 5
==Computational class==
I don't know, but as the integers are unbounded and the ability to infinite loop, I think it's TC.
Category:2024Category:OISCCategory:UnimplementedCategory:Unknown computational classCategory:No IOCategory:Low-level
DDDD

DDDD is an esoteric programming language whose only data structure is a single deque. It was created by User:Andrew3335 in 2021 and is intended to be used for golfing, although the restriction to printable ASCII limits its brevity.
==Specification==
Here is a link to the specification.
==Sample programs==
===Hello, World!===
NHello, World!}J
N...} puts an element containing "Hello, World!" at the end of the deque. J looks at the back element and prints it.
===Cat program===
iK
i takes STDIN and creates a new element at the deque's top. K looks at the front element and prints it.
==Computational class==
DDDD is Turing-complete as the instructions :()^ from Underload are in DDDD.
Category:Languages Category:2021 Category:Turing complete Category:Deque-based Category:Golfing language
DDR

DDR is an esoteric programming language created by User:DoggyDogWhirl. It is inspired by the video game series Dance Dance Revolution, and takes many of its commands from brainfuck.
==Commands==
DDR code is meant to resemble incoming arrows from Dance Dance Revolution. Each command is made of four arrows (<v^>) and is on its own line. Code must start with "<v^>" to represent the guide arrows at the top, or else a syntax error is raised.
These commands are equivalent to brainfuck commands:
 > >
 < <
 ^ +
 v -
 v^ .
 <v ,
 < ^ [
 v > ]
Similarly, a blank line and all characters other than <v^> are considered comments and are ignored.
These are the other commands:
 ^> Output the value in the cell at the pointer
 <v^ Sets the variable to the value in the cell at the pointer (the variable is set to 0 by default)
 v^> Sets the value in the cell at the pointer to the variable
 < > The next two commands are never run, and instead converted to a number which stored in the cell at the pointer (e.g. " v >" and " v^>" are converted to 01010111, and stored as 87)
 < ^> All commands between this command and its next instance are stored as a function and not run
 <v > Calls the function
 <v^> Halt the program
==Example programs==
===2===
Outputs "2".
 <v^>
 ^
 ^
 ^>
===Cat program===
 <v^>
 <v
 < ^
 v^
 <v
 v >
===Hello, world!===
 <v^>
 < >
 v
 <
 v^
 < >
 v^
 v >
 v^
 < >
 v^
 <v
 v^
 v^
 >
 < >
 v^
 <v^>
 v^
 >
 < >
 ^
 <v
 v^
 < >
 ^
 
 v^
 < >
 v^>
 v^>
 v^
 <
 v^
 < >
 v^>
 ^
 v^
 <
 v^
 < >
 v^
 v
 v^
 < >
 ^
 >
 v^
==Implementation==
Implementation in Python
Category:Languages
Category:2019
Category:Brainfuck derivatives
Category:Implemented