nyuuzyou/wikis huggingface dataset:
???

??? is an esoteric programming language created by Stack Exchange users Alex A. and BrainSteel. It uses the punctuation within a literary work to perform operations akin to those of Brainfuck.
The name “???” was chosen so that it would be hard to tell that a program in an unknown language was written in this language. The name is hard to search for, and ironically matches the “???” text meaning “language not yet identified” in the programming challenge that inspired it.
==Language overview==
Like Brainfuck, ??? operates on an array of memory cells, also referred to as the tape, each initially set to zero. There is a pointer, initially pointing to the first memory cell. The commands are:
Command	Description
; 	Move the pointer to the right
- 	Move the pointer to the left
. 	Increment the memory cell under the pointer
, 	Decrement the memory cell under the pointer
! 	Output the character signified by the cell at the pointer
? 	Input a character and store it in the cell at the pointer
" 	Jump to the matching " if the cell under the pointer is 0
' 	Toggles whether subsequent " commands (in the source) start or end a loop
All other characters do not affect execution and can be regarded as comments.
This language is very similar to a TrivialBrainfuckSubstitution; nested loops can be implemented using the ' command to specify which double quotes match which other double quotes.
Initially, " begins a loop.
==Programs==
===Cat Program===
 ?"!",'"?"
===Hello World===
 ..........";.......;..........;...---,'";..!;.!.......!!...!;..!--...............!;!...!,,,,,,!,,,,,,,,!;.!
==External resources==
* Interpreter
Category:Languages
Category:Brainfuck equivalents
Category:Turing complete
Category:Implemented
Category:2015
?Q?

?Q?(pronounced Qustjeon or /ˈkwɛstʎən/) is a esolang created in a afternoon by User:Yayimhere.
== name ==
the name comes from the file format .?Q? which is a file thats compressed, typically by the SQ program
== memory ==
memory is stored in a string initially set to the empty string
== syntax ==
* ~ add a ) to the string if the start of the string is (. to make it add a ( instead a & is placed before it
* . delete all brackets that does not have a matching bracket(so for example the string (() becomes ())
* […] set the string to …
* ? add a space to the code if the start of the string is (
* ! delete the end of the string
* , set string to user input
* $ output the string
* * go back to the start of the code if the string is not empty
* {…} append … to the string
* ` append the string to itself
* # if the following command has already been ran skip it
* : run the string as code
* @ reverse the string
== tips ==
* if you want to only loop a specific part of the program add # to the part thhats before the loop.
* : makes it a little bit possible to create functions
== examples ==
hello, world!:
 [hello, world!]$
Cat:
 ,$
Looping counter:
 {*\n}$!!*
unary exponent:
 #{*}`*
Truth-machine with 0 as ) and 1 as 1:
 #,$.*
== computational class ==
?Q? is Turing complete since it can simulate a Bitwise Cyclic Tag with a ( as 1 and a space as 0. this is a substitution to do so:
 11 : &~ 
 10 : ?
 0 : @!@
the program must end with a *. and to set up the datastring:
 #{data} the data must be in ?Q? format
so the Collatz sequence provided on the BCT page is:
 BCT program: 10 11 10 10 10 11 0 11 10 10 0 11 10 10 11 10 10 11 10 10 0 0 0 0
 ⇅
 ?Q? program: #{( }?&~???&~@!@&~??@!@&~??&~??&~??@!@@!@@!@@!@*
note that the number of times ( is repeated in the append, is how many times 100 is added to the string. if you want to print the string every iteration $ can be added before the *. so the collatz sequence would become:
 #{( }?&~???&~@!@&~??@!@&~??&~??&~??@!@@!@@!@@!@$*
on the first 7 relevant iterations it prints(not including the semicolons) for the number 3:
 ?Q? 
 step# Collatz term ?Q? data-string
 ----- ------------ ------------------------
 0000 3 ( ( ( ;
 0096 5 ( ( ( ( ( ;
 0240 8 ( ( ( ( ( ( ( ( ;
 0432 4 ( ( ( ( ;
 0528 2 ( ( ;
 0576 1 ( ;
 0624 2 ( ( ;
and the script for number the number 3:
 #{( ( ( }?&~???&~@!@&~??@!@&~??&~??&~??@!@@!@@!@@!@$*
Category:Languages
Category:String-rewriting paradigm
Category:Turing complete
Category:Low-level
Category:Turing tarpits
? $51=

? $51= is an esoteric language made by someone. It is an easy language to do boring things in.
==Hello World! program==
Here is a Hello World! program.
 $? 5 Hello World! 5
See? a bit hard but is easy! For help I'm going to put the command list:
Command 	Meaning
$? 5 TEXT 5 	print TEXT
$??$$ ... 51? 	if ... then
er15?...$?! 	while...do
51az? 5 5 =...	local " " =...
Category:Languages
Category:Unimplemented
Category:Unknown computational class
Category:Output only
Category:Usability unknown
@!+-()

@!+-() is an esolang by User:ChuckEsoteric08. Language was named after 6 main commands in the language
==Specification==
Uses Queue and Accumulator as memory.
 @ - enqueue accumulator
 ! - dequeue element and store it in accumulator
 + - increment accumulator
 - - decrement accumulator
 ( - if accumulator is zero go past matching )
 ) - go back to matching (
 , - output accumulator as ASCII character
 . - store ASCII value of the next byte of user input in accumulator
==Examples==
===Cat===
 .(,.)
===Print "HI"===
 ++++++++++@(-)@!(-@!+++++++@!)!++,+,
===Implementing conditional statements===
You could make "if" statement, which would run if accumulator is nonzero (with a caveat that it would set accumulator to 0 after it ran).
====If statement====
Ask for input and if it is nonzero enqueue it:
 .(@(-))
====If-else statement====
Ask for input and if it is nonzero output it, else output "H":
 .@(-)+@!(,@!-@(-))!@!(!(-)++++++++++@(-)@!(-@!+++++++@!)!++,(-))
===Truth machine===
 .------------------------------------------------(++++++++++++++++++++++++++++++++++++++++++++++++,------------------------------------------------)++++++++++++++++++++++++++++++++++++++++++++++++,
==See also==
* @!%2B-()_Turing-completeness_Proof
==External resources==
*Interpreter in Scratch
Category:Languages Category:Turing complete Category:Turing tarpits Category:Implemented Category:Queue-based
@!+-() Turing-completeness Proof

@!+-() is Turing complete because it can simulate brainfuck but we need to compile it to intermediate language called "queuefuck"
==Queuefuck==
Queuefuck has following commands:
 . - enqueue zero
 + - dequeue, increment, enqueue again
 - - dequeue, decrement, enqueue again
 ^ - dequeue and enqueue again
 " - dequeue and enqueue 2 times
 [ - dequeue and if zero go past matching ]
 ] - go back to matching [
 ; - dequeue and output
 : - enqueue user input
 / - dequeue
==Compiling n-cell brainfuck to queuefuck==
Note than x(n) means that command x is repeated n times.
 initalisation - .(n)
 + - +^(n-1)
 - - -^(n-1)
 > - ^
 < - ^(n-1)
 [ - "^(n-1)[
 ] - "^(n-1)]
 . - "^(n-1);
 , - /:^(n-1)
==Compiling queueuefuck to @!+-()==
 . - (-)@
 + - !+@
 - - !-@
 ^ - !@
 [ - !(
 ] - !)
 ; - !,
 : - .@
 / - !
 " - !@@
Category:Proofs
@NUM

== @NUM ==
@NUM is my first programming language (the name is based on the structure of the code). The language itself consists of a syntax of 12 "words".
@NUM is based on the size and simplicity of Brainf***, but adds the ability for dynamic memory manipulation. This language uses a cell based memory system and can technically have methods!
Symbols	Purpose?
# 	sets current address to the number on the right
@ 	sets current cell value to the number on the right(only positive permitted)
, 	returns current point in input (the ascii number of the character)
$ 	prints current cell value (in ascii)
! 	prints current cell value (the integer value)
= {} 	if the number to the right of the ? is equal to the current cell value, then the code inside is the {} performed, otherwise it is skipped
> {} 	if the number to the right of the > is greater than the current cell value, then the code inside is the {} performed, otherwise it is skipped
< {} 	if the number to the right of the < is less than the current cell value, then the code inside is the {} performed, otherwise it is skipped
E {} 	while the number to the right of the E is equal to the current cell value, then the code inside is the {} performed, otherwise it is skipped
G {} 	while the number to the right of the G is greater than the current cell value, then the code inside is the {} performed, otherwise it is skipped
L {} 	while the number to the right of the L is less than the current cell value, then the code inside is the {} performed, otherwise it is skipped
F {} 	for 0 to the number to the right of the F is less than the current cell value, then the code inside is the {} performed, otherwise it is skipped, sets current index to it's iterative index (0 to num)
% 	the number on the right of this is the address of a cell, and the % sign returns the value of that cell(valid as return number for all syntax requiring it)
i 	returns the length of input
^ 	returns square of number on the right
: 	returns current cell address
== To Do ==
I just need to finish my interpreter, which has a couple bugs, and then make some examples
Category:Cell-basedCategory:Languages
@minor!

Hello World:
 [(=_):${a--z||A--Z}]
 [A--Z++++++++|a--z+++++|a--z++++++++++++|a--z++++++++++++|a--z+++++++++++++++]
 [>==<]
 [(ascii):${32}]
 [>==<]
 [A--Z+++++++++++++++++++++++|a--z+++++++++++++++|a--z++++++++++++++++++|a--z++++++++++++|a--z++++]
OUTPUT: hello world
Fibonacci (limit: 9, sum: 50):
 [(=_):${*||+}]
 [|-->[+]-->+++++++++||]
 [
 -->ascii::(+|[+<-->--<--+])
 ]
OUTPUT: 1,2,3,5,7,12,19,31,50
3s0!an9 b0y
Category:Languages
A

A is a programming language that uses only the letter A in its source code. Its creation year is uncertain but no later than 2008.
== Description ==
A program with less than 8 As is interpreted as a single command in Brainfuck as follows:
Number of As 	Brainfuck 	Description
0 	> 	Move the pointer to the right
1 	< 	Move the pointer to the left
2 	Increment the memory cell under the pointer	
3 	 	
Decrement the memory cell under the pointer	 	
4 	. 	Output the character signified by the cell at the pointer
5 	, 	Input a character and store it in the cell at the pointer
6 	[ 	Jump past the matching ] if the cell under the pointer is 0
7 	] 	Jump back to the matching [ if the cell under the pointer is nonzero
If a program has 8 or more As, the program is interpreted recursively by taking the command corresponding to the remainder when the number of As is divided by 8, and appending it to the program corresponding to a string of As of length equal to the quotient when the number of As is divided by 8. In other words, the number of As is divided by 8, where the remainder, then the quotient, is interpreted. This has the effect of converting the number of As to base 8, then interpreting each digit from left to right.
Programs in A are constructed similarly to those in Unary, albeit more efficiently. For instance, the cat program written in Brainfuck as ,[.,] requires only 23855 As (56457 in octal), as opposed to 56623 0s in Unary.
Any program in A has the same length as the corresponding Ellipsis program (in non-compatibility mode); therefore, a program in either language can be converted to the other by a simple text substitution.
== See also ==
*Brainfoctal
*Ellipsis
*Lenguage
*MGIFOS
*Unary
*Dotfuck
== External links ==
* 
Category:Turing tarpits 
Category:Brainfuck equivalents
Category:Languages
Category:Unknown year
Category:Cell-based
Category:Low-level
Category:Implemented
Category:Turing complete
A-gram

a-gram is an esoteric programming language that only accepts Unicode characters with "gram" in their name as valid characters.
== Syntax == 
=== Basic commands ===
Command 	Description
⚍ (LESSER YIN) 	Grabs a single character from console and pushes its ASCII value onto the stack
⚌ (GREATER YANG) 	Outputs the value on the top of the stack as an ASCII character
⚎ (LESSER YANG) 	Outputs the value on the top of the stack as a number
䷨ (DECREASE) 	Decrements the value on the top of the stack
䷩ (INCREASE) 	Increments the value on the top of the stack
☰ (HEAVEN) 	Pushes 1 onto the stack
䷀ (THE CREATIVE HEAVEN)	Pushes 127 onto the stack
䷯ (THE WELL) 	Pushes a random number between 0 and 127 onto the stack
䷏ (ENTHUSIASM) 	Squares the value on the top of the stack
䷶ (ABUNDANCE) 	Duplicates the value on the top of the stack
䷠ (RETREAT) 	Takes the value from the bottom to the top of the stack
Note that if nothing is on the stack, using INCREASE and DECREASE will return with an error message. 
Any other unrecognised character will be ignored by the compiler.
=== Flow control === 
a-gram allows you to loop based on certain conditions.
You may start a loop by using the DURATION hexagram, ䷟. There are multiple conditions on which to loop based on. These are placed directly after the DURATION hexagram.
Condition 	Description
䷼ (INNER TRUTH) 	Loops while the current value on the stack is truthy (greater than 0)
䷺ (DISPERSION) 	Loops while the stack has values in it
䷫ (COMING TO MEET) 	Pops a value off the stack and then loops until the value currently on the stack is equal to the popped value
䷽ (SMALL PREPONDERANCE)	Pops a value off the stack and then loops until the value currently on the stack is less than the popped value
䷛ (GREAT PREPONDERANCE)	Pops a value off the stack and then loops until the value currently on the stack is greater than the popped value
䷄ (WAITING) 	Loops infinitely
The loop then must have a hexagram for BEFORE COMPLETION (䷿) to start the loop block, as well as a hexagram for AFTER COMPLETION (䷾) to end it.
For example, here is a simple yes-like program, along with an explanation of how it works.
 ⚍䷟䷄䷿䷶⚌䷾
⚍ Grab single character from STDIN
䷟ ䷄ Loop forever
䷿ {
 ䷶ Duplicate value on stack
 ⚌ Pop value off stack and print it
䷾ }
As well, there is one additional flow-control related command: RETURN (䷗). This command jumps to the start of any loop it is in. If it is not in a loop, it will instead jump to the start of the file, making infinite loops that surround the entire program easier.
== Example programs == 
=== Hello, world! ===
☰䷩䷩䷩䷩䷩䷩䷩䷏䷩䷩䷩䷩䷩䷩䷩䷩⚌
䷀䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷨䷶⚌
䷩䷩䷩䷩䷩䷩䷩䷶⚌ 
䷶⚌
䷩䷩䷩⚌
☰䷩䷩䷩䷩䷩䷩䷏䷨䷨䷨䷨䷨⚌
☰䷩䷩䷩䷩䷩䷏䷨䷨䷨䷨⚌
䷀䷨䷨䷨䷨䷨䷨䷨䷨䷶⚌
䷨䷨䷨䷨䷨䷨䷨䷨䷶⚌
䷩䷩䷩䷶⚌
䷨䷨䷨䷨䷨䷨䷶⚌
䷨䷨䷨䷨䷨䷨䷨䷨⚌
☰䷩䷩䷩䷩䷩䷏䷨䷨䷨⚌
☰䷩䷩䷩䷩䷩䷩䷩䷩䷩⚌
This outputs "Hello, world!" with a trailing newline.
=== Echo program ===
䷟䷄䷿⚏䷟䷺䷿䷠⚌䷾䷾
This fairly short program loops infinitely, echoing anything it receives from STDIN to STDOUT.
== Implementations == 
* Interpreter written in Ruby by the author.
Category:Languages
A345120268A9

A345120268A9 is a tape-based language based off of brainfuck & designed by User:RXVT100
==Syntax==
A345120268A9 has 14 commands, 13 not including np (NOP)
every command is 2 characters and takes up to 4 arguments
Command	Description
mp 	move the pointer, relatively or absolutely
rt 	read a value/all values from the tape. print as digits.
wt 	write tape. values can be from -18446744073709551615 to 18446744073709551615
bo 	bit operation. AND, OR, and XOR can be used.
ri 	read input. can be read in like brainfuck or raw to the cell
cm 	compare. can use `=`, `!=`, `>` and `<`
em 	extra math. can use `**`, `%`, `*`, and `/`
rb 	read binary. write the current cells ASCII value as raw data
pt 	print text. uses `printf "%b"`
sv 	save value. can save all cell values or pointer value
lv 	load value. can only be done if there are saved values.
np 	nop. do nothing.
cl 	call. source a bash script.
wn 	while not. run commands until a condition is met.
'relative' is adding or subtracting to the current value
'absolute' is declaring the value, like `x=5` instead of `x+=5`
==Examples==
Cheat Hello World:
 pt "Hello, World!"
'Real' Hello World:
 wt a + 72;rb;wt a + 101;rb;wt r + 7;rb;rb;wt r + 3;rb;wt a + 44
 rb;wt r - 12;rb;wt a + 87;rb;wt r + 24;rb
 wt r + 3;rb;wt r - 6;rb;wt r - 8;rb;wt r - 67;rb;wt r - 23;rb
==Interpreter==
Interpreter & full command/argument list
Category:Languages
Category:Cell-based
Category:Implemented
A=B

A=B (pronounced "A to B") is a text replacement-based esolang. Similarly to ///, the only instruction is text replacement, but there are several keywords that add extra functionality that is not present in ///.
This language is the premise of the video game of the same name by Artless Games (the team behind the game Understand) released on 2022 March 29.
== Description ==
The language takes a single line of text as input, and a list of instructions, one per line, as the code. At its very basics, each line of code is in the following format: A=B, where the first occurrence of the substring A in the input gets replaced with B.
Comments are notated with the character #. All characters from # to the end of the line is ignored.
Blank lines and comment lines are not counted as lines of code.
A=B can only take ASCII characters as input and code, except for comments.
On each step of execution, the interpreter tries to apply the first substitution rule in order that can be applied. When the input is such that no substitution rules can be applied, the state of the modified input is output.
Below is a simple example program that converts the characters a, b, and c to uppercase:
a=A
b=B
c=C
When this program is run on the input abacbcab, the input will be mutated in this order:
* abacbcab
* Abacbcab
* AbAcbcab
* AbAcbcAb
* ABAcbcAb
* ABAcBcAb
* ABAcBcAB
* ABACBcAB
* ABACBCAB
=== Keywords ===
Keywords are added to the language as the player progresses through the puzzles in the game.
keyword 	function
A=(return)B	(World 2) Halts the program and outputs B instead of the input state.
(start)A=B 	(World 3) Only matches the start of the input.
(end)A=B 	(World 3) Only matches the end of the input.
A=(start)B 	(World 3) Appends the replacement to the start of the input.
A=(end)B 	(World 3) Appends the replacement to the end of the input.
(once)A=B 	(World 4) Only executes the rule once per program.
== Example ==
=== Cat program ===
A blank A=B program returns the input as its output, so a blank A=B program is already a cat program.
Input: anything
Code: nothing
=== Hello world ===
Input: anything
Code:
=(return)Hello, world!
=== Truth-machine ===
Because A=B does not have streamed output, this truth-machine will duplicate the 1 in an endless loop.
Input: 0 or 1
Code:
1=11
0=(return)0
Category:Languages
Category:String-rewriting paradigm
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Self-modifying
Category:Implemented
Category:2022
A?!

A?! is a minimalistic esoteric programming language, created by User:Someone else.
== Description ==
Alphanumeric variables can be created that contain boolean values. There are input and output streams, that both operate in ASCII. Input is streamed in little endian, and output is in big endian.
Syntax 	Function 	Notes
<variable>! 	Flips specified variable. 	
<variable>? 	Skips next instruction if specified variable is false. 	Comments don't count as instructions.
<variable>. 	Sends the value of specified variable to the output stream. 	Letter is only printed when all 8 bits are specified. The program won't fill in zeroes if 8 bits aren't reached, and will throw an error.
<variable>...	Gets one bit from the input stream and puts it in the specified variable. 	Realtime input is supported. If it's called again after EOF, the program halts.
>>>...>	Skips in forward direction the same amount of instructions as there are >. A single >, for instance, would skip only the immediately following instruction line.	Counts as one instruction.
<<<...<	Moves back an amount of lines equal to the tally of consecutive <. A single <, for example, would return to the line immediately preceding this instruction. 	> and < can't be mixed together. It wouldn't make sense anyway.
Everything between a # and a newline is a comment. A newline is required after every instruction. Additional newlines are ignored.
==Computational class==
There is only 62 alphanumeric variable names. And that's including case-sensitivity. Considering that they are all just bits, this language is hardly useful for computation.
If we get rid of this limitation, the computational class would be a finite-state automata, because there is no relative addressing, cell values are finite, but flow control is still possible.
==Examples==
===Truth machine===
 # The variable 'A' stores the bit value zero (0).
 A...
 A...
 # The variable 'B' stores the bit value one (1).
 B...
 B...
 # The variable 'C', through the last input, stores either 0 or 1.
 C...
 C...
 C...
 C...
 
 # Print the input as an ASCII character.
 A.
 A.
 B.
 B.
 A.
 A. 
 A.
 C.
 
 # If the user input was 0, skip the iterative section.
 C?
 # This instruction, encountered for a 1 input, jumps to the loop.
 >
 # This instruction, encountered for a 0 input, skips the coming loop.
 >>>>>>>>>
 
 # Start of the iterative printing section for an input of 1.
 A.
 A.
 B.
 B.
 A.
 A. 
 A.
 C.
 <<<<<<<<
 
===Infinite loop===
 >
 A! #This instruction will never be executed.
 <<
===Cat program===
 A...
 B...
 C...
 D...
 E...
 F...
 G...
 H...
 A.
 B.
 C.
 D.
 E.
 F.
 G.
 H.
 <<<<<<<<<<<<<<<<
===Increment a single-digit number: (wrap around)===
 #Input
 A...
 B...
 C...
 D...
 E...
 F...
 G...
 H...
 
 #Increment
 H?
 >
 >>>>>>>
 G?
 >
 >>>
 F?
 E!
 F!
 G!
 H!
 
 #Wrap-around
 E?
 >
 >>>>>
 G?
 >
 >>
 E!
 G!
 
 #Print
 A.
 B.
 C.
 D.
 E.
 F.
 G.
 H.
== See also ==
* A
* A:;
* AAAAAAAAAAAAAA!!!!
==Interpreter==
* Common Lisp implementation of the A?! programming language.
Category:Thematic
Category:Implemented
Category:finite state automata
Category:Languages
A?b.

A?b. (not capitalized except at the start of a sentence) is a language invented by User:Masalt, using Python 3.8.12. It consists of a starting variable, ten rules, each spanning two lines, to apply to the variable each tick, an ending value, and a post-completion message (to be repeated 10 times upon completion). The interpreter can be found here.
==Examples==
===Truth machine===
 ?
 2
 ?
 3
 ?
 4
 ?
 5
 ?
 6
 ?
 7
 ?
 8
 ?
 9
 ?
 0
 .
 .
 .
 .
 /
===Hello World===
 Hello
 Hello
 world
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 world
 /
Output:
 hello
 
 world
 
 
 //////////
===Cat===
 ?
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 .
 /
Category:Unknown computational class Category:Implemented Category:2022
AAA

AAA is a brainfuck-like programming language, the difference is, that you can only write the letter A in AAA.
 Syntax
AAAA 	brainfuck
AaAa 	-
AAAA 	+
aAaA 	>
AAaa 	<
aaAA 	[
aaaA 	]
aaaa 	,
aAaa 	.
(Comments!)	Comments!
== Examples ==
=== Hello world ===
(Hello, world! in AAA)
aAaAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAaaAAAAaaAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAaAaAAaAaaa
aAAAaaaAaaaAaAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAaaAAAAaaAAAAAAAAAA
AAAAAAaAaAAaAaaaaAAAaaAAAAaAaa
AAAAAAAAAAAAAAAAAAAAAAAAAAAAaA
aaaAaaAAAAAAAAAAAAaAaaaaAAAaAa
aaaAaAaAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAaaAAAAaaAAAAAAAAAAAA
AAAAaAaAAaAaaaaAAAaaaAaaaAaAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAaaAAAAaaAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAaAaAAaAa
aaaAAAaaAaAaaAaaAaAaAaAaAaAaAa
AaAaAaAaAaAaAaAaAaaAaaAAAAAAAA
AAAAaAaaAaAaAaAaAaAaAaAaAaAaAa
AaaAaaAaAaAaAaAaAaAaAaAaAaAaAa
AaAaAaAaaAaaaaAAAaAaaaaAaAaAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
aaAAAAaaAAAAAAAAAAAAAAAAaAaAAa
AaaaaAAAaaAAAAaAaaaaAAAaAaaaaA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAaAaa
=== Cat ===
(Cat program in AAA)
AAAAaaAAaaaaaAaaaaaA
Category:Languages
Category:Joke languages
Category:2022
Category:Cell-based
Category:Brainfuck equivalents
Category:Turing complete
Category:Turing tarpits