nyuuzyou/wikis huggingface dataset:
Subleq/subleq.py

:
This is a public domain interpreter and simple assembler for Subleq, written in Python 3. It can assemble and run the Hello, world! example on the Subleq article.
#!/usr/bin/env python3
import sys
class Subleq:
 def __init__(self):
 self.mem = []
 def assemble(self, source_text):
 labels = self.collect_labels(source_text)
 self.write_contents(source_text, labels)
 def collect_labels(self, source_text):
 labels = {}
 def label_it(s, addr):
 if ':' in s:
 label, contents = s.split(':')
 labels[label] = addr
 addr = 0
 for line in source_text.split("\n"):
 line = line.strip()
 if not line or line.startswith('#'):
 continue
 [a, b, c] = line.split()
 label_it(a, addr)
 label_it(b, addr + 1)
 label_it(c, addr + 2)
 addr += 3
 return labels
 def write_contents(self, source_text, labels):
 def write_it(v, addr):
 if ':' in v:
 label, contents = v.split(':')
 v = contents
 if v in labels:
 v = labels[v]
 if v == '?+1':
 v = addr + 3
 self.mem.append(int(v))
 addr = 0
 for line in source_text.split("\n"):
 line = line.strip()
 if not line or line.startswith('#'):
 continue
 [a, b, c] = line.split()
 write_it(a, addr)
 write_it(b, addr)
 write_it(c, addr)
 addr += 3
 def dump_triples(self, f):
 addr = 0
 while addr < len(self.mem):
 a = self.mem[addr]
 b = self.mem[addr + 1] if addr + 1 < len(self.mem) else 0
 c = self.mem[addr + 2] if addr + 2 < len(self.mem) else 0
 f.write('{} {} {}\n'.format(a, b, c))
 addr += 3
 def load_triples(self, f):
 for line in f:
 a, b, c = line.split()
 self.mem.append(int(a))
 self.mem.append(int(b))
 self.mem.append(int(c))
 def run(self, trace=False):
 pc = 0
 while pc >= 0:
 a = self.mem[pc]
 b = self.mem[pc + 1]
 c = self.mem[pc + 2]
 if trace:
 print('pc={}, a={}, b={}, c={}'.format(pc, a, b, c))
 at_a = self.mem[a]
 if b >= 0:
 at_b = self.mem[b]
 result = at_b - at_a
 self.mem[b] = result
 elif b == -1:
 sys.stdout.write(chr(at_a))
 result = 0
 if result <= 0:
 pc = c
 else:
 pc += 3
def main(args):
 if len(args) == 3 and args[0] == 'assemble':
 subleq = Subleq()
 subleq.assemble(open(args[1], 'r').read())
 with open(args[2], 'w') as f:
 subleq.dump_triples(f)
 elif len(args) == 2 and args[0] == 'run':
 subleq = Subleq()
 with open(args[1], 'r') as f:
 subleq.load_triples(f)
 subleq.run()
 elif len(args) == 2 and args[0] == 'trace':
 subleq = Subleq()
 with open(args[1], 'r') as f:
 subleq.load_triples(f)
 subleq.run(trace=True)
 else:
 print('usage: subleq.py assemble in.subleqasm out.triples | run in.triples | trace in.triples')
 sys.exit(1)
if __name__ == '__main__':
 main(sys.argv[1:])
Category:Implementations
Subskin

Subskin is an OISC variant with a very short (148 bytes of code) Ruby implementation written by Jannis Harder in 2005.
Subskin is an abbreviation for "subtract and skip if negative", which is the only instruction.
==The machine==
===The instruction===
Each instruction has 3 words called (AP BP RP).
The instruction is
 if( (memory[IP[2]]=memory[IP[0]]-memory[IP[1]]) < 0) skip();
or
 if( (*RP = *AP - *BP) <0) skip();
Negative memory offsets result in undefined behavior.
===Memory===
The memory consists of an infinitely large array of signed bignums. If an undefined memory value is read, the program terminates.
===Registers===
There are 3 memory mapped registers
* IP (Instruction Pointer) at position 0.
* OR (Output Register) at position 1. If >= 0 it is written as character. Values >= 256 result in termination of the program. After printing the character it is set to -1.
* IR (Input Register) at position 2. If < 0 a byte from STDIN is read and written into the register. On EOF a 256 is written into IR.
The Register actions for Input and Output are evaluated before the instruction.
==The implementation==
The implementation is 148 bytes of Ruby code released into the public domain.
===Source code===
 m=readlines.map{|e|e.hex};loop{m[1]<0||$><<m[1].chr&&m[1]=-1;m[2]<0&&m[2]=
 STDIN.getc||256;a,b,c=m[m[0],3];q=(m[c]=m[a]-m[b])<0?6:3;m[0]+=q}rescue 0
===File format===
Subskin code files (.subskin) contain one word of memory on each line in hex representation. Empty lines / lines without hex numbers are counted as zeros. The hex number has to be the first non-space character on the line, all characters after the first hex number are ignored.
==Examples==
===Cat program===
 3-10672010261D30
===Hello, world!===
 448010327021313890656c6c6f2c20776f726c6421a100
===Hello, world! 2 (Improved)===
 3480c21313000656c6c6f2c20776f726c6421a100
===Hello, world! 3 (Improved again)=== 
See Hello world program in esoteric languages#Subskin
==See also==
* MISC
* Simpler Subskin
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:Low-level
Category:Self-modifying
Category: 2005
Category: OISC
Subterra

Subterra is a tarpit-style language created by Katrina Scialdone that attempts to get as close to being a proper imperative programming language as possible within the following restrictions:
* Only single-character instructions
* A single stack rather than variables
* Integers are the only datatype (syntactic sugar excepted)
To this end, it implements a unique subroutine system that allows for simple pseudo-functions, as well as an import system (a rather unusual feature for a tarpit language).
==Language reference==
An up-to-date language reference is maintained on GitHub (see External Resources).
==Computational class==
Subterra is Turing-complete (and in fact has numerous Turing-complete subsets). The simplest way to show this is to see that the stack can be reversed using @, effectively making it into a double-ended queue (i.e. enough data storage ability for Turing-completeness), and the language has no shortage of useful control flow structures ({} subroutines don't do any stack manipulation, thus can be freely used for control flow without disturbing the data storage).
More complex Turing-completeness constructions also exist, e.g. using the call stack and the data stack as the two stacks required to store the required amount of data.
==Examples==
===Hello, world!===
Recursive:
 0{s0>?{c0#}}"Hello world!"$0#
Non-recursive:
 "Hello world!"w[0>]{bct1-}
===99 bottles of beer=== 
 ~ Includes proper plurals!
 
 0 { w [0>] { bct1- } $ } ~ Simple print function
 
 100 w {1-&0>} [
 	&p" bottle"0#&1!?(\sc)" of beer on the wall,\n"0#
 	&p" bottle"0#&1!?(\sc)" of beer,\n"0#
 	"Take one down, pass it around,\n"0#
 	1-&0=?("No"0#):[p]" bottle"0#&1!?(\sc)" of beer on the wall.\n\n"0#
 ]
===Cat program===
Recursive: (warning: will crash with large inputs!)
 0{s0>?{c0#}}i$0#
Non-recursive:
 iw[0>]{bct1-}
===Collatz sequence===
Change the 25 at the beginning to change the starting number.
 25 w [1>] {
 	&p10c
 	&2%0!? {3*1+} : {2/}
 } p
===Factorial===
Change the 5 on line 3 to change the input number.
 0 { &1>?{&1-0#}s1>?{*} }
 
 5;0#p
==External resources==
* Subterra on GitHub
Category: Languages
Category: 2016
Category: Implemented
Category: Stack-based
Category: Turing complete
Subtle cough

Subtle cough is an esoteric programming language by User:ihope127 that can be defined as Unlambda with c as its only function primitive. That is, the set of Subtle cough programs is the set of Unlambda programs which use only the characters ` and c, and the Subtle cough programs do the same thing as these Unlambda programs.
There are only three nonequivalent expressions (and thus programs):
;c
:The Unlambda primitive.
;`cc
:Evaluating this in any continuation ends up returning that continuation to itself. The expressions `c`cc and ``ccc both have the same effect.
;``cc`cc
:Never terminates. Neither does any expression containing it.
It follows that ` acts essentially as a simple ternary logic operator:
` 	c 	`cc 	``cc`cc
c 	`cc 	`cc 	``cc`cc
`cc 	`cc 	``cc`cc	``cc`cc
``cc`cc	``cc`cc	``cc`cc	``cc`cc
This language clearly has too little computational power to be used for programming.
==Calculation of operator table==
We will evaluate the expressions using Unlambda meta-notation.
 `cc = `c(*) = `(*)(*) = (*).
 `c`cc = `c(`c*) (from above)
 = `(`c*)(*) = `c(*) = `(*)(*) = (*).
 ``ccc = `(`*c)c = `cc = (*).
 ``cc`cc = `(`*`cc)`cc = `(`*`cc)(`(`*`cc)*) = `(`(`*`cc)*)`cc
 = `(`*`cc)`cc (circular, because (`(`*`cc)*) = (`*`cc)).
 `c``cc`cc evaluates the ``cc`cc.
 ``cc``cc`cc = `(`*``cc`cc)``cc`cc, at which point ``cc`cc is evaluated.
 ```cc`cc``cc`cc evaluates the first ``cc`cc.
Category:Languages
Category:Functional paradigm
Category:Unusable for programming
Category:Esoteric subset
Subway

The Subway language attempts to mimic the workings of a railway system in order to produce a program. It's unique in the it has the potential for some paralleled computation in that multiple cars may be running on the "line" simultaneously.
==Language Specifications== 
Code is written in the form of a continuous "track". Each "train" on the track is a stack, and each "car" is a stack element. There is a global accumulator, referred to as the "station". The station determines how the data in the last car (the top stack element) is modified. Cars may be connected or disconnected (pushed and popped) and start as empty.
Only a positive number of people may be in each car, however, negative numbers are representable as the value of a car is a normalised value of the number of people on the car. A car has 2^16 - 1 seats (a 16-bit binary value) and the value is normalised by 2^15 - 1.
. Thus the value of a car is shown by:
 (num people) - (2^15 - 1)
Which means the largest value is "32768" and the smallest is "-32767".
Up to four trains may be on the track at any given time. They are defined at different starting points.
Each train moves in a direction along the track given by an integer.
 0 Right
 1 Up
 2 Left
 3 Down
The direction can be changed during execution when a directional or conditional instruction is encountered.
 > Right
 ^ Up
 < Left
 V Down
 ~ Up if last_car is empty, Otherwise Down (ignored if moving up/down)
 : Right if last_car is empty, Otherwise Left (ignored if moving left/right)
Cars may be connected or disconnected using the push and pop instructions
 . Connects a new car with 32767 passengers "push(32767);"
 , Passengers in the last car replace the passengers in the station and the car is disconnected "ST = pop();"
There are four arithmetic instructions
 + Addition (last_car = last_car + station)
 - Subtraction (last_car = last_car - station)
 * Multiplication (last_car = last_car * station)
 / Division (last_car = last_car / station)
A constant hexadecimal digit c = [0,A] sets the numbers of passengers in the station to 2^c. Any other constant, non-instruction symbol sets the station to zero.
Input/Output is possible
 $ Input (station = stdin)
 @ Output (stdout = station)
And finally the starting/terminating points and empty track may be defined with
 w Starting point for train0
 x Starting point for train1
 y Starting point for train2
 z Starting point for train3
 S Termination point
 = Empty track
==Examples==
A simple program which takes two numbers from user input, adds them together and then prints them.
 V=<
 w.o*.$+^
 + S
 >=~==<
 >,@^
Suc

Suc is an esolang by User:ChuckEsoteric08 based on a Succesor machine
==Specification==
Suc uses unbounded amount of registers (which are 0-indexed) to store values. Line numbers are also 0-indexed.There are only three commands:
 INC x y
Increment register x by y.
 CLR x
Set register x to zero.
 JEQ x y z
If registers x and y are equal goto line z.There is also optional command which is used for debuging:
 OUT x
Which outputs value of register x. And thats it! Now try do to something useful with it
==Some useful snippets==
Unconditional jump:
 JEQ x x z
Following examples use something called "label notation" which uses labels instead of line number:
 a:
Would declare label a
Add registers x and y using temporary register z:
 CLR z
 inc:
 INC x 1
 INC z 1
 JEQ z y done
 JEQ x x inc
 done:
Copy value of register x to register y:
 CLR y
 inc:
 INC y 1
 JEQ x y done
 JEQ x x inc
 done:
Multiply value of register x by 2 and use a and b as temporary registers:
 CLR a
 CLR b
 inc:
 INC a 2
 INC b 1
 JEQ b x done
 JEQ b b inc
 done:
 CLR x
 inc2:
 INC x 1
 JEQ x a done2
 JEQ x x inc2
 done2:
If we change it a little bit we could get division by 2:
 CLR a
 CLR b
 inc:
 INC a 1
 INC b 2
 JEQ b x done
 JEQ b b inc
 done:
 CLR x
 inc2:
 INC x 1
 JEQ x a done2
 JEQ x x inc2
 done2:
Decrement x using temporary registers y and z:
 CLR y
 CLR z
 INC y 1
 dec:
 INC z 1
 INC y 1
 JEQ x y tox
 JRQ x x dec
 tox:
 CLR x
 cpy:
 INC x 1
 JEQ x z done
 JEQ x x cpy
==Computational class==
The language is Turing-complete becauese it can simulate Incrementing machine. Insturction a b c d converts to:
 a:
 INC b 1
 JEQ c d
==See also==
* Sucks
Category:Languages Category:Turing complete Category:Turing tarpits Category:Unimplemented Category:Low-level
Sucks

Sucks is a derivative of Suc by User:ChuckEsoteric08
==Description==
It's syntax is very similar to Suc, but with following additions:
 IN x
Would input a number and store it in register x
 CIN x
Would input byte x and store it's value in reigster x
 OUT x
Ouptput register x as a number, unlike in Suc it's not an optional command
 COUT x
Output reigster x as a character
 *x
Would replace argument with value of register x, but it can't replace a line number
==Short form==
In this version all of the commands are replaced with their one-character equivalents
 INC x y
Becomes:
 +x+y
 CLR x
Becomes:
 _x
 JEQ x y z
Becomes:
 =x=y=z
 IN x
Becomes:
 ,x
 OUT x
Becomes:
 .x
 CIN x
Becomes:
 ;x
 COUT x
Becomes:
 :x
Category:LanguagesCategory:Turing completeCategory:Turing tarpitsCategory:UnimplementedCategory:2024Category:Low-level
Sulbimate

Sulbimate is an Esoteric programming language created by User:Buckets in 2024, They thought about punch cards to much and thought about punch cards a dimension lower, a paper tape, A Flimsy Paper tape and thought "Can I do Control flow with only folding the paper tape?" And here we are.
(The fold pointer will be in-between the data pointer's cell and the right cell of that data pointer's cell and the input puncher will be placed Where the data pointer is.)
(Also note that When a cell gets punched, the punched cell will be forever 1, as well as the overlapping paper consequences.)
Commands	Instructions
< 	Move the fold place 1 to the left.
> 	Move the fold place 1 to the right.
% 	Read current cell.
@ 	Punch current cell (Will also punch the rest of the paper that is overlapping that cell.)
1 	If = 1 then move the fold place 1 to the Left.
0 	If = 1 then move the fold place 1 to the Right.
I 	Create Input puncher.
O 	Emit newest data read.
{ 	Move Input puncher 1 cell to the left.
} 	Move Input puncher 1 cell to the right.
l 	Punch Input puncher.
+ 	Fold to the Right.
- 	Fold to the Left.
[ 	Unfold Nearest fold.
] 	Unfold Newest fold.
. 	Anti-fold Nearest fold.
, 	Anti-fold Newest fold.
Cat Program:
 IlO
Category:Cell-based
Category:2024
Category:Languages
Category:Joke languages
Sultan's daughter

The sultan's daughter is a partial function on digit strings defined in Raymond Smullyan's book The Riddle of Scheherazade (1997). 
== Definition ==
The machine implements a partial function p whose domain and range is the set of non-empty strings of digits 0 to 9 (strings starting with digit 0 are probably forbidden). The function is defined by five rules. Here, ++ means concatenation, reverse means reversing the order of digits in a string, & tail means dropping the first digit of a string.
;Rule 1: If x is a nonempty digit string, then p(1 ++ x ++ 2) = x.
;Rule 2: If x is a nonempty digit string and p(x) is defined, then p(3 ++ x) = p(x) ++ p(x).
;Rule 3: If x is a nonempty digit string and p(x) is defined, then p(4 ++ x) = reverse(p(x)). 
;Rule 4: If x is a nonempty digit string and p(x) is defined and has at least two digits, then p(5 ++ x) = tail(p(x)).
;Rule 5: If x is a nonempty digit string and p(x) is defined, then p(6 ++ x) = 1 ++ p(x), and p(7 ++ x) = 2 ++ p(x).
== Discussion ==
The string 47536414753642 is a fixed point given in the book. A shorter fixed point is 47431474312.
== Implementation ==
The following perl code defines the function sd which computes p, or returns undef if p is not defined.
 sub sd {
 if ($_[0]=~/\A([3-7]*)1([0-9]+)2\z/) {
 my$t=$2;
 for my$p(reverse split//,$1) {
 $t = 3 eq$p ? $t x2 : 4 eq$p ? reverse$t :
 5 eq$p ? (1<length$t?substr($t,1):return undef) :
 6 eq$p ? 1 .$t : 7 eq$p ? 2 .$t : die;
 }
 return $t;
 } else {
 return undef;
 }
 } 
== History ==
According to the story in the book, the sultan's daughter (princess) implements this function. The sultan made prince Al-Khizr find a fixed point and some other strings with interesting properties to test his worthiness to marry the princess.
McCulloch's second machine and McCulloch's third machine are related functions defined in an earlier book.
Category:Languages
Category:1997
Category:Implemented
Category:String-rewriting paradigm
Category:People
Sundays

Sundays is an Esoteric programming language created by User:Buckets in 2020.
Commands 	Instructions
0 (or 0.)	Create A new variable.
1 	Change the variable to the Newer Created Variable.
2 	Change the variable to the Older Created Variable.
3 	Print the number currently stored in ASCII.
4 	Set the Input.
5 	Add The next Number.
6 	Subtract The next Number.
7 	Multiply the next number.
8 	Divide the next number.
9 	If the current number stored is 0, Then go to 6 , Else 8 , And Indexing it by the Proceeding Numbers Until 9 again, For Example 989 if 0, go to 86 , else 88 .
 	Noop.
(All variable start with 0, At the start there is no variables.)
Truth-machine Program:
 0.4919 16 705176783 929 18 705177773919 28
Cat program:
 0.43
Category:Joke languages
Category:Languages
Category:2020
SuperScript

SuperScript, not to be confused with superscript, is an esolang made by User:Yes that was made with the design goal of being easy to implement while also being super irritatingly hard to program in (hence the "super" in the name, but it almost impossible to program in.)
== Commands ==
i increment register
d decrement register
e end
o output register as ascii
n output register as number
e is used to end programs midexecution. the program will end automattically at the end.
== Quirk ==
SuperScript will interpet command (register) (register) times, with the register always starting at 1
So the pesudocode
Increment 1
End
is the same as
i
Ok, that isnt much of a diffrence, but the example will get you to know the potential of this quirk.
== Example ==
Output 4, 4 times. (Output: 4444) 
iiin
Program in pesudocode:
0 |start
1 |increment register
2 |repeat 2
2.5| increment register
4 |repeat 4
4.5| output register as number
== Rating ==
As of [insert the time im writing the edit here], the Esolang Quality Rating System will give SuperScript a (0-30-5-30-5) -70.
== Wimpmode ==
There is a wimpmode, called SubScript also not to be confused with subscript, being SuperScript without the quirk. So the example above will print
3
in SubScript.
Category:Languages Category:Output only Category:Total Category:Unusable for programming
Super SNUSP

Super SNUSP is a language inspired by the brainfudge derivative SNUSP. It has additional commands from other bf derivatives, like:
* Decimal I/O
* Arithmetic and bitwise operators
* A stack
* And more!
==Commands==
 Caption text
Charcode 	Ascii	Opcode	Meaning
032 	Space	NOP 	Do nothing
033 	! 	SKIP 	Skip next instruction
034 	" 	START 	This is where the IP starts. Starts at bottom right if not found.
035 	# 	OUT 	Print cell value as decimal
036 	$ 	DROP 	Pop the stack and discard
037 	% 	MOD 	Modulo cell by stack top (has sign of cell)
038 	& 	AND 	Bitwise and cell by stack top
039 	' 	END 	This is where the IP ends
040 	( 	DEC 	Subtract 1 from cell
041 	) 	INC 	Add 1 to cell
042 	* 	MULT 	Multiply cell by stack top
043 	+ 	ADD 	Add stack top to cell
044 	, 	KEY 	Get char input into cell
045 	- 	SUB 	Subtract stack top from cell
046 	. 	EMIT 	Print cell as byte character
047 	/ 	RULD 	Same as in SNUSP
048 - 057	0-9 	SET 	If last command was digit, multiply by 10, else zero out and add literal value
058 	: 	DIV 	Divide cell by stack top, rounded towards negative infinite
059 	; 	ROOT 	Set cell to stack top root of cell (rounded towards negative infinity, even root of negative is error)
060 	< 	BAK 	Move pointer backwards by 1
061 	= 	RAND 	Set cell to a random number between cell and stack pop
062 	> 	FWD 	Move pointer forwards by 1
063 	? 	SKIPZ 	If cell == 0, perform a SKIP.
064 	@ 	IN 	Input decimal number into current cell
064 - 090	A-Z 	- 	Set cell to ASCII value of letter
091 	[ 	LSH 	Left shift cell by top of stack bits
092 	\ 	LURD 	Same as in SNUSP
093 	] 	RSH 	Right shift
094 	^ 	XOR 	Bitwise xor cell by stack top
095 	_ 	NEG 	Multiply cell by -1
096 	` 	SKIPN 	If cell is negative, perform a SKIP.
097 - 122	a-z 	- 	Set cell to ASCII value of letter
123 	{ 	STO 	Push cell to stack
124 	 	OR 	Bitwise or cell by stack top
125 	} 	RCL 	Set cell to stack top
126 	~ 	NOT 	Bitwise not current cell
==Examples==
Hello, World!: 
 "33>d>l>r>o>W>32>44>o>l>l>e>H!/ ?\' 
 \<./
Cat:
 ,!/ ?\'
 \,./
==Computational class==
Turing complete, because it has all of SNUSP's commands, except that + and - are replaced by ( and ).
Category:LanguagesCategory:Cell-basedCategory:Stack-basedCategory:Two-dimensional languagesCategory:Turing completeCategory:Unimplemented
Supertape

The whole program is made up of a main normal tape, containing some number of values, normal tapes, or cyclic tapes. 
Here on out the current memory tape's pointer will be called the memory pointer, and the current instruction tape's pointer will be called the instruction pointer (keep in mind they can be the same)
= Instructions =
Instruction	When ran with the memory pointer pointing at a tape 	When ran with it pointing to a character
< 	Move the memory pointer left 	Same
> 	Move the memory pointer right 	Same
v 	Set the memory tape to the tape pointed at by the memory pointer 	Who knows?
^ 	Set the memory tape to the tape containing the current memory tape 	Same
: 	Set the instruction tape to the tape pointed at by the memory pointer 	Who knows?
; 	Set the instruction tape to the tape containting the current instruction tape (doesn't change the pointer of either) 	Same
@ 	Duplicate the thing pointed at by the memory pointer, and point at the first one 	Same
$ 	Put the thing pointed at by the memory pointer in a new normal tape 	Same
& 	Put the thing pointed at by the memory pointer in a new cyclic tape 	Same
% 	Dump the contents of the tape pointed to by the memory pointer 	Who knows?
+ 	Replace the tape pointed at by the memory pointer with the sum of all elements in it (including elements in tapes inside it) 	Increment the value pointed at by the memory pointer
- 	Run '-' on all elements of the tape pointed at by the memory pointer 	Negate the value pointed at by the memory pointer
! 	Run '!' on all elements of the tape pointed at by the memory pointer, then output a newline if the tape is non-cyclic 	Output the value pointed at by the memory pointer as a Unicode character
? 	Take a line of input from the user, and insert a tape containing the values of each (not including the newline) at the memory pointer (pushing the prior thing pointed to to the right)	Same
The instruction pointer prior to the instruction running always increments after the instruction is ran.
If, after incrementing, the IP is past the end of the tape, the IP gets reset to 0 and (if the instruction tape is not cyclic) the instruction tape becomes whatever previously held the instruction tape. This differs from a ';' break, because when the tape is left via semicolon it doesn't reset the IP. Other than that, it is the same.
Category: Languages
Category: Cell-based
Category: Turing complete
Category:Low-level