nyuuzyou/wikis huggingface dataset:
Qiunx

Qiunx (pronounced chunks, styled as qiunx) is a stack-based programming language created in 2024 by squandle. It was designed to be similar to assembly languages.
==Language Overview==
qiunx operates on two different data structures: an infinitely long stack, which can hold only integer values; and 26 registers (ax through zx), which can hold string, boolean, and integer values. These registers can be accessed with the mfs (move from stack), mts (move to stack), and mov (move) opcodes, which are explained further in depth in the opcodes section.
==Opcodes==
! NOTE ! not all opcodes are implemented right now.
Opcode 	Stack state 	Description 	Usage example
Arithmetic 	 	 	
add 	a b -- a + b	pops the top two values off the stack, adds them together, and pushes the result to the stack 	:100 :4 add (* 104 *)
sub 	a b -- a - b	pops the top two values off the stack, subtracts the second value from the first, and pushes the result to the stack 	:32 :12 sub (* 20 *)
mul 	a b -- a * b	pops the top two values off the stack, multiplies them together, and pushes the result to the stack 	:10 :10 mul (* 100 *)
div 	a b -- a / b	pops the top two values off the stack, divides the first value by the second value, and pushes the result to the stack	:100 :20 div (* 5 *)
Stack manipulation 	 	 	
pop 	a b -- a 	removes the top value from the stack and prints it to STDOUT as an ascii character 	:111 pop (* prints "e" *)
dup 	a b -- b b 	duplicates the top value from the stack 	:10 dup mul (* 100 *)
:n 	N/A 	when n is a number, it is pushed to the stack 	:104 (* pushes 104 to the stack *)
mts r 	a b -- b c 	pushes the value at register r to the stack 	mov 78 cx mts cx
Register manipulation	 	 	
mov n r 	a b -- a b 	pushes n to register r 	mov 104 ax (* moves 104 to the ax register *)
mfs r 	a b -- a 	moves the top value of the stack to register r 	:68 mfs gx (* pushes 68 to the stack, then moves it to the gx register *)
==Example Programs==
===Hello, world!===
:10 :33 :100 :108 :114 :111 :119 :32 :44 :111 :108 :108 :101 :72 pop pop pop pop pop pop pop pop pop pop pop pop pop pop
as the language evolves, this will as well, but as of now strings and loops do not exist.
Category:2024Category:Stack-basedCategory:LanguagesCategory:Works-in-ProgressCategory:Unimplemented
Qoibl

==Overview==
Qwerty oriented impractical bicharacter language (Qoibl) is an esoteric programming language created on the 10th of June 2021 by User:Toxinite. Qoibl is quite simple, having only eight instructions and a single list which is 256 variables long, starting at zero.
==Commands==
 Instructions
Code	Description 	Example code
tt 	Prints whatever number that is between it as ASCII 	tt yyyey tt
we 	Sets something in the list (we x we y we) 	we y we yyey we
qe 	Allows access to information in the list (qe x qe) 	we qe yye qe we yy we
et 	Gets input from the user in ASCII 	we yy we et we
e/y 	Binary numbers in which e is zero and y is one 	tt yeeeeey tt
yr 	Used for conditions where ee, ey, ye and yy mean =, >, < and != respectively (yr x yr)	rr et yr yy yr qe yyyey qe rr tt qe y qe tt rr
ry 	Used for math where ee, ey, ye and yy mean +, -, x and / respectively (ry x ry) 	tt et ry yy ry yyey tt
rr 	Used as a while loop (rr x rr y rr) 	rr qe yee qe yr ey yr yey rr tt qe yy qe tt rr
Keep in mind that it ignores characters not included in the instructions e.g. space.
==Small programs==
Hello world program:
 tt yeeyeee tt
 tt yyeeyey tt
 tt yyeyyee tt
 tt yyeyyee tt
 tt yyeyyyy tt
 tt yeyyee tt
 tt yeeeee tt
 tt yyyeyyy tt
 tt yyeyyyy tt
 tt yyyeeye tt
 tt yyeyyee tt
 tt yyeeyee tt
 tt yeeeey tt
 tt yeye tt
One digit adder (up to 4+5):
 we e we yyeeee we
 we y we et ry ey ry qe e qe we
 we ye we et ry ey ry qe e qe we
 we y we qe y qe ry ee ry qe ye qe we
 we y we qe y qe ry ee ry qe e qe we
 tt qe y qe tt
Truth-machine:
 we e we et we
 rr qe e qe yr ee yr yyeeey rr tt yyeeey tt rr
 tt yyeeee tt
Cat computer:
 rr e yr ee yr e rr tt et tt rr
== Implementations ==
A Python interpreter by User:Bangyen.
Category:Languages Category:2021 Category:Low-level Category:Implemented
Qoppa

Qoppa is a Scheme-like language designed by User:Kmc as a proof-of-concept which eliminates syntactic special forms. It is based around operatives, a lexically-scoped version of fexprs. Every syntactic form is either a variable name or an application of an operative to zero or more operands. There is a built-in operative vau which is used in a manner similar to lambda to construct other operatives.
== External resources ==
Qoppa was heavily inspired by Kernel.
The original blog post contains a detailed description of the language along with an implementation in Scheme. The interpreter is equipped with a standard library which implements enough Scheme primitives to run the interpreter itself.
There is another implementation using PyPy.
Qoppa was also implemented as part of a research paper on debuggers.
Qq

qq is an esoteric language created by User:ehird in 2008. It is based on quoting programs taken to the (il)logical extreme. It's kind of like Underload, but not really, but not at all.
== Syntax ==
=== Expression ===
*( expression+ )
*integer
Whitespace is ignored, apart from the fact that it can be used to separate integers.
=== Program ===
*expression*
== Evaluation ==
If the first element is an integer, we execute it's associated command, with the rest of the program/quoted program, unevaluated, as arguments.
If the first element is a quoted program, we execute it as a toplevel program, then use that as the command number (as above).
== Commands ==
(arity 1+) The first argument must be an integer, the rest anything. Execute the command numbered by the first argument with the arguments of the rest of the arguments evaluated. (Phew!)
(arity 1) Return the argument, unscathed.
(arity 2) Both arguments must be quoted programs. They are munged (concatentated) together.
(arity 1) Munges the quoted program argument with itself.
(arity 2) Both arguments must be integers. They are added together.
(arity 2) Both arguments must be integers. They are subtracted. If a negative value results, they get added instead.
(arity 0) A character is read from standard input and returned as its ASCII number.
(arity 1) The argument must be an integer. It is printed out, as its ASCII character, to the screen. Then it is returned.
(arity 3) The arguments may be anything. If the first argument is 0, the third argument is returned, otherwise the second is returned.
(arity 1+) The first argument must be an integer. An integer is returned, which when called as a command, is like calling the first argument with the arguments of the rest of the arguments to this command plus the arguments passed to the returned command. (...Of course!)
== Examples ==
=== One-character cat ===
Reads one character in, and prints it out.
 (0 7(6))
==== How it works ====
0 is being called with 7 and (6), so it knows it has to run the command 7, but with what arguments? Well: 0 runs it with the rest of the arguments it gets, but evaluated, unlike a normal call. So: we run the program (6), which calls 6, which reads a character from input and returns it. Then we run 7 with that character, printing it out.
== External resources ==
* Interpreter, written in Common Lisp (warning: the dead link currently leads to a porn site.)
Category:2008
Category:Languages
Category:Implemented
Quagdonic numbers

=== Definition ===
A number n\in\mathbb N,n\ge1 is m-quagdonic (m\in\mathbb N,m\ge2) iff there exists k\in\mathbb N,k\le\left\lfloor\log_m n\right\rfloor such that
:\prod_{i=k}^{\left\lfloor\log_m n\right\rfloor}\left(\left\lfloor m^{-i}n\right\rfloor\bmod m\right)=\left(n\bmod m^k\right)
=== Syntax ===
Source code consists of integers m and n, respectively, separated by space.
The output are the first n m-quagdonic numbers, separated by spaces.
=== Example ===
Input: 10 200
Output:
 11 22 33 44 55 66 77 88 99 100 101 111 122 133 144 155 166 177 188 199 200 202 212 224 236 248
 300 303 313 326 339 400 404 414 428 500 505 515 600 606 616 700 707 717 800 808 818 900 909 919
 1000 1001 1010 1020 1030 1040 1050 1060 1070 1080 1090 1100 1101 1111 1122 1133 1144 1155 1166
 1177 1188 1199 1200 1202 1212 1224 1236 1248 1300 1303 1313 1326 1339 1400 1404 1414 1428 1500
 1505 1515 1600 1606 1616 1700 1707 1717 1800 1808 1818 1900 1909 1919 2000 2002 2010 2020 2030
 2040 2050 2060 2070 2080 2090 2100 2102 2112 2124 2136 2148 2200 2204 2214 2228 2300 2306 2316
 2400 2408 2418 2500 2510 2600 2612 2700 2714 2800 2816 2900 2918 3000 3003 3010 3020 3030 3040
 3050 3060 3070 3080 3090 3100 3103 3113 3126 3139 3200 3206 3216 3300 3309 3319 3400 3412 3500
 3515 3600 3618 3700 3721 3800 3824 3900 3927 4000 4004 4010 4020 4030 4040 4050 4060 4070 4080
 4090 4100 4104 4114 4128 4200 4208 4218 4300 4312 4400 4416 4500 4520 4600 4624 4700
== External resources ==
* Implementation
Category:Languages
Category:2024
Category:Implemented
Qualm

qualm is an esoteric programming language designed and created by User:Wilfreddv. The name "qualm" was chosen to reflect the uneasy feeling you get when looking at it.
== Examples ==
=== Hello, world! ===
 v'Hello, world!:!
The v'...: stores the string Hello, world! into the working cell. The ! prints it out.
=== Truth machine ===
 .i{w=1{!}
The `.` reads from standard input, and gets converted to an integer using `i`. If the result is `1`, it enters a loop that prints `1`. Since `w` isn't changed inside the loop, it will run infinitely.
=== Fibonacci sequence ===
 v2>0v1>1{s1<=100{!iv'\n:!<1+<0s0}
This code will compute the Fibonacci sequence up until a 100.
Category:Languages
Category:Implemented
Category:2021
Category:Turing_complete
Category:Cell-based
Quantum INTERCAL

Quantum INTERCAL was first introduced by CLC-INTERCAL version 0.04. It is based on a very simple idea: when you ABSTAIN FROM or REINSTATE a statement, you are really changing the value of a single bit, which records whether the statement should be executed or not. Similarly, for IGNORE and REMEMBER. Now replace this bit with a quantum bit. As soon as you do anything which may change this bit, your program will exist in a superposition of two quantum states, one in which the statement is ABSTAINed FROM, and one in which it is REINSTATEd.
The above discussion naturally suggested a syntax to distinguish between normal ABSTAIN FROM/REINSTATE and the quantum version: compare the following statements:
# DO ABSTAIN FROM (1)
# PLEASE REINSTATE (1)
# DO ABSTAIN FROM (1) WHILE REINSTATING IT
# PLEASE REINSTATE (1) WHILE ABSTAINING FROM IT
The first two statements are non-quantum, the next two are quantum. Incidentally, the two quantum statements listed are entirely equivalent, they both result in a quantum bit which is 50% true and 50% false. The matter becomes complicated if you use a non-quantum statement to set a bit which was previously set by a quantum statement; the interested reader can just write such a program, feed it to the compiler and see what happens. Alternatively, the theory of quantum superposed states can be applied to see what it has to say.
Version 1.-94 of CLC-INTERCAL greatly extended the quantum possibilities. Now every statement which can modify data has a quantum version. For example, the statement:
 DO .1 <- #2 WHILE NOT ASSIGNING TO IT
is equivalent (more or less) to:
 PLEASE IGNORE .1 WHILE REMEMBERING IT
 DO .1 <- #2
 DO REMEMBER .1
Interaction between Quantum INTERCAL and other extensions of CLC-INTERCAL can be a bit weird sometimes, and will be discussed when my head stops spinning
Note that googling "Quantum INTERCAL" returns references to a program in which multiple COME FROMs all pointing at the same label will cause a program to create superposed quantum states. Whoever wrote that was confusing Quantum INTERCAL with Threaded INTERCAL
Also note that a quantum superposition of states is not the same as a probability: for example:
 DO .1 <- #1
 DO %50 .1 <- #2
 DO READ OUT .1
 PLEASE GIVE UP
Will output either I or II, each case selected with equal probability. By contrast:
 DO .1 <- #1
 DO .1 <- #2 WHILE NOT ASSIGNING IT
 DO READ OUT .1
 PLEASE GIVE UP
Will output both I and II, because the program enters a superposition of two states, one in which .1 has value #1 and another one in which it has value #2.
Please note that observing the program running may cause collapse of the quantum state function, and therefore result in observable probabilities instead. However, the quantum emulator which comes with CLC-INTERCAL does not do this.
==External resources==
* 
Category:Languages
Category:Quantum computing
Category:Implemented
Quantum Nothing

This is an esolang created by islptng.
==Syntax==
Every program with 1 byte or more is invalid. It runs the following code, which raises a Syntax Error:
 +++++++++[->+++++++++<]>++.<++++++[->++++++<]>++.<+++[->---<]>--.++++++.<++++[->----<]>---.<++++[->++++<]>+++++++.<+++++++++[->---------<]>-------.<++++++[->++++++<]>+.<++++++[->++++++<]>+++++++++..---.+++.<
Otherwise, For every valid Brainfuck program of each length, execute it once.
For length 1, 6: + - < > , .
For length 2, 37: ++ -- +- -+ << >> <> >< ,, .. ., ,. +> +< -> -< >+ >- <+ <- ,+ ,- ,> ,< .+ .- .> .< +, -, >, <, +. -. >. <. []
etc.
Category:Languages Category:Unusable for programming Category:Unimplemented Category:2024 Category:Cell-based Category:Brainfuck derivatives Category:Zero-dimensional
Quantum brainfuck

Quantum brainfuck is an esolang by Ihope127 which is essentially brainfuck operating on qubits instead of integers. The tape starts initialized with all 1's. The commands:
 < Move the tape head left.
 > Move the tape head right.
 % Perform the Hadamard transform on the current qubit.
 ! Perform a controlled-V on the current qubit and the one to the right of it.
 & Swap the current qubit with the one to the right of it.
 , Input to the current qubit.
 . Output the current qubit.
 [ While observing the current qubit gives a 1...
 ] End while.
The controlled-V gate acts as identity, unless both the control and the target are 1, in which case they are multiplied by the imaginary unit before being returned. Output works using a CNOT, so that the output qubit and the qubit on the tape are entangled.
Controlled-V as a matrix:
 [1 0 0 0]
 [0 1 0 0]
 [0 0 1 0]
 [0 0 0 i]
==Examples==
==== Truth Machine ====
,[.].
=== Hello world ===
Hello world in binary
[%].&.&..&.&....&.&&.&..&.&.&.&.&
.&&.&.&.&&.&...&.&&.&.&.&&.&...&.
&&.&.&.&&.&&.&&.&..&.&.&.&&.&....
&.&......&.&&.&&.&.&.&&.&&.&.&.&
&.&.&.&&.&&.&&.&.&.&&.&&.&..&.&.
.&.&&.&.&.&&.&...&.&&.&..&.&....
&.&....&.&
==External resources==
*An implementation by User:lament, written in Python, is currently available:
*:https://github.com/graue/esofiles/blob/master/qbf/impl/qubit.py
*:https://github.com/graue/esofiles/blob/master/qbf/impl/qbf.py
*:(2 files to download)
*Quantum computers on Wikipedia
Category:Languages
Category:2006
Category:Nondeterministic
Category:Cell-based
Category:Unknown computational class
Category:Brainfuck derivatives
Category:Implemented
Category:Low-level
Category:Quantum computing
Quasar

Quasar is a esolang created by User:Yayimhere where code is just loops. the memory is stored in a queue bits
== how it works ==
a loop is set up like this: 
 [loop body]
a loop is managed with a queue. a 1 is enqueued while the loop is being performed. a 0 is enqueued when a loop ends. on that a loop ends when there is more than 8 bits in the queue in which the queue queue is emptied or the loop is empty(in this case there will not be a 1 enqueued). when a 0 is before a 1 that 0 is dequeued. when something is dequeued the counter(yes there is an unbounded counter) is incremented. and also when the queue is emptied. also anything else is just a loop escape
== tips ==
to push 1 and 0:
* [a] to push 1
* [] to push 0
Category:Languages Category:Queue-based
Quebe

Quebe (Queue of Bytes) is an esolang which is inspired by ResPlicate by User:ChuckEsoteric08 
==Description==
Quebe uses a queue made out of bytes and has initial state which is an nonempty string.
===Execution===
At each step, a symbol is dequeued (let's call it x) and enqueue string starting at the front a queue to n, where n is how many times x appears in the queue after it was dequeued. If n is zero or it's bigger than length of a queue execution stops 
==Examples==
 abbaa
 bbaabba
 baabbabaa
 aabbabaaaab
 abbabaaaababbaba
 bbabaaaababbababbabaaaa
 babaaaababbababbabaaaababaaaaba
 ...
Category:Languages Category:Unknown computational class Category:Queue-based Category:Unimplemented
Queen

Queen is a WIP Language by User:Pro465, based on a call queue.
 Commands
Command	action 	description
_ 	(x) -> (x) 	does nothing
, 	(.., x) -> (.., x, <input char>)	receives input and pushes to front of queue
. 	(.., y, x) -> (.., y) 	pops off the front of queue and prints its corresponding ascii character
: 	(.., x) -> (.., x, x) 	duplicates the front value
; 	(..,y,x) -> (<ip>, .., y) 	saves current ip on thee back of queue, then jumps to immediately after the x-th command
/ 	(x, .., y) -> (y, x, ..) 	pass the value at front of queue to the back
+ 	(.., y, x) -> (.., <x + y>) 	add
- 	(.., y, x) -> (.., <x - y>) 	subtract
# 	(.., x) -> (.., x, 1) 	push 1
$ 	(.., y, x) -> (.., y) 	discard value at front of queue
=== Examples ===
==== Cat ====
_#$,.#;
==== Hello, world! ====
#:+:+:+#+:+:+:+.
#:+#+:+:+:+#+:+:+#+.
#:+#+:+:+#+:+#+:+:+.
#:+#+:+:+#+:+#+:+:+.
#:+#+:+:+#+:+#+:+#+:+#+.
#:+:+#+:+#+:+:+.
#:+:+:+:+:+.
#:+#+:+#+:+:+#+:+#+:+#+.
#:+#+:+:+#+:+#+:+#+:+#+.
#:+#+:+#+:+:+:+#+:+.
#:+#+:+:+#+:+#+:+:+.
#:+#+:+:+:+#+:+:+.
#:+:+:+:+:+#+.
==== Truth machine ====
#:+#+:+:+:+:+,-:+:+:
+:+:+#:+:+#+:+:+:++;
_#:+:+:+#++.$____$#:
+#+:+:+:+:+#+.#:+#+:
+#+:+:+:+;
Category:Languages
Category:Queue-based
Category:Unknown computational class
Quelcal

Quelcal /'kju:l.kæl/ is an esolang created by CreeperBomb in 2023. In it, programs are represented by button presses on typically calculator, plus a check operator and the number i. Specifically, these are:
Quelcal	Calculator button
0 	0 digit
1 	1 digit
2 	2 digit
3 	3 digit
4 	4 digit
5 	5 digit
6 	6 digit
7 	7 digit
8 	8 digit
9 	9 digit
. 	Decimal point
i 	N/A (Complex number i)
+ 	Addition
- 	Subtraction
x 	Multiplication
÷ 	Division
± 	Negate
= 	Equate
? 	N/A (Check)
Checking is a trinary operator that takes in any number, a natural number, and an integer, in that order, with its symbol between these. The natural number represents a particular set. If the leftmost number is not in the set that the natural number represents, then the program jumps forward the integer number lines. Otherwise, nothing happens. Checking happens after addition/subtraction. For example, 3?1?0 would jump to itself and loop. The sets and associated number are:
Number	Set
0 	Natural numbers (incl. 0)
1 	Integers
2 	Rationals
3 	Reals
4 	Complex numbers
==Turing completeness==
Quelcal is trivally Turing complete as, using multiplication, division, digits, and checks, a multiplicative Minsky machine can easily be simulated. However, for specification purposes, a proof of equivalence to and completeness of such a machine will be provided.
Let us refer to "Quelcal" as "Q" and "multiplicative Minsky machine" as "MMM" for short. For formatting reasons, newlines will also be replaced with "n". Consider Q programs starting with 1. Now, add x2 & x3 for any multiplication by 2 or 3 in an MMM's code. Division is similar, but with an extra bit attached to the end; ÷2=?0?1nx2 and ÷3=?0?1nx2 for division by 2 or 3. This shows being at least as powerful as an MMM. An MMM can also be shown as Turing complete as its incremental/decremental couterpart by recognizing that, since 2 & 3 are coprime and not equal to -1, 0, or 1, an MMM's state can be represented by two numbers correponding to the amount of factors of 2 and of 3, which get incremented or decremented in the exact same manner as a regular Minsky machine, with the same decremental behavior at 0. Thus, Q is at least Turing complete, and since there the rest of its features do not grant it super-Turing complete computational abilities, Q is precisely Turing Complete.
Quell

Quell (Queue call) - is an esolang by User:ChuckEsoteric08. It was created as a compilation target for high-level languages which use Call Queue that could be compiled into Sque bytecode
==Specification==
Quell uses infinte tape which can hold unbounded values. It also uses Call Queue for subroutines.*x returns value in cell x
===Commands===
 SET x y - set cell x to y
 ADD x y - add cell x and cell y and store in x
 SUB x y - subtract cell y from cell x and store in x
 JMP x - jump to subroutine x
 JNZ x y - if cell x is not zero jump to subroutine y
 JZ x y - if cell x is zero jump to subroutine y
 JEQ x y z - if cell x is y jump to subroutine z
 RET - return from subroutine
 INP x - input one byte and store it in x
 OUT x - output x as ASCII character
 abc: - subroutine called abc
===Additional commands===
If the language would be compiled to Quell and then to Sque, then following commands can be used, but they are optional and examples would only use instructions above:
 STR x y - set x to string y
 INT x y - set x to integer y
 BOOL x y - set x to boolean y
 JGT x y z - jump if greater than
 JLT x y z - jump if less than
 MUL x y - multiply
 DIV x y - divide
 MOD x y - modulo
 ADD x y - if at least one of the cell is a string, then concatenate
 INP x - input string and set cell x to it
 OUT x - output cell x
 CHR x y z - set cell x to y-th chatacter in string z
==Examples==
===Cat===
 loop:
 	INP 0
 	OUT 0
 	JNZ 0 loop
Category:Languages Category:Unimplemented Category:Cell-based
Quest

Quest is a language by User:ChuckEsoteric08 for making text-based games
==Syntax==
Syntax look like that
 <text><command><arguments>
It prints <text> and executes command <command> that have arguments
Commands are:
\	gets input and goes to line based on it. The arguments look like that:
 <value>?<line>
It goes to line <line> if input is <value>(counting starts from 1). If there isn't anything before "?" then it goes to line if input is anything else. Arguments separated with spaces
/	goes to line specified by argument unconditionally. If there isn't anything after command, jump to next line. If you jumping out of bounds, program halts
==Examples==
===Hello World===
 Hello, World!/
===Truth machine===
 Input:\1?2 0?3
 1/2
 0/
Category:Languages Category:Unimplemented Category:Finite state automata
Questa

Questa(from "Queue and stack ") is an Esoteric data structure by User:ChuckEsoteric08, that is similar to the Deque, but you can push elements only on the top.
==Operations==
The Questa's abstract nature conditions a representation by its basic functionality.
===Basic Operations===
There are four basic operations in Questa:
Operation	Function
PUSH 	Push element on top of the Questa
POP1 	Pop element from top of the Questa
POP2 	Pop element from bottom of the Questa
SWAP 	Swaps element from bottom with element from top
===The Questa ADT===
The Questa as an abstract data type (ADT) shall be specified in the following:
PUSH(x : any) : void — Pushes the element x to the top of the Questa and returns no value.
POP1() : any — Returns the Questa's top element. If the Questa is empty, an error will be signaled.
POP2() : any — Returns the Questa's bottom element. If the Questa is empty, an error will be signaled.
SWAP() : boolean — Exchanges the position of the Questa's top and bottom elements. If the Questa contains one or more items a Boolean value of true will be returned; for an empty Questa false is produced.
==Questa-complete==
Questa-based languages can be called "Questa-complete" if:
*The data capacity is unbounded
*All of the basic commands listed above are implemented
==Questa-based languages==
Four Questa-based languages are currently in existence:
Language 	Questa-completeness
Quests 	Yes
Miw 	No
Toki pona li pona	Yes
==Implementations==
* Common Lisp implementation of the Questa data structure. Please note that some assumptions have been introduced in order to rectify the lacunae.
==See also==
* Resta
Category:Data Types and Structures Category:2022