nyuuzyou/wikis huggingface dataset:
ANItka

ANItka lang is an esoteric programming language designed by Radek. It was developed on the spur of the moment for author's girlfriend Anita.
ANItka lang was inspired by COW. Language syntax based on many variants of Anitka word. Memory available at the runtime is only limited by the implementation of an interpreter.
==Instruction Set==
All instructions are listed on the ANItka lang Home Page. Currently the language has 21 opcodes including IF and LOOP statements.
==Examples==
Prints the result of 4 x 2 expression:
 aNitka aNitka aNitka aNitka Anitka aNitka aNitka Anitka ANITka aNiTkA
Loop which prints 4 hearts and bunny at the end:
 aNitka aNitka aNitka aNitka ANITkA ANItkA anitKa ANiTKA aniTKA
Compare if two numbers are equal. If true prints heart otherwise bunny
 anItka Anitka anItka anitkA ANItKA ANItkA aNITKA ANiTKA aniTKA
==External resources==
* 
Category: Languages
Category: Cell-based
Category: Implemented
Category: 2016
APL

The original APL, a notation for mathematics and programming, was
invented by Ken Iverson in the late 1950s and published in his
1962 book A Programming Language. It is a non-esoteric programming language predominantly used in finance. However, due to the reliance on non-ASCII characters, unique semantics and abundance of exploratory concepts being introduced into APL even today (such as tacit function trains), it can be squarely put into the esoteric category. 
The original notation for APL involved
lists of statements in a box, with arrows connecting lines to indicate control flow,
all written in a notation reminiscent of mathematics, complete with
mixed Greek and Latin alphabets, super- and subscripts and weird
invented symbols. The values of variables could be numbers, strings,
multi-dimensional arrays and trees.
APL is important for two reasons: first, it turned out to be a useful
notation for describing computer hardware (operational details of
the IBM /360 series were all worked out in APL) and second, an interactive
time-shared implementation of a big part of the language was made available
around 1967. The implementation left out the tree data structures, and
greatly simplified the notation to make it possible to type programs in,
but retained the weird character set by using a typewriter terminal
with customizable fonts (the IBM 2741, a Selectric typewriter with
a computer interface.)
APL is the founding member of the APL-like family of languages, which includes J and K.
== Example code ==
Calculate all prime numbers from 2 to 1000:
 N←1000
 (2=+⌿0=∘.|⍨⍳N)/⍳N
Calculate Golden mean iteratively (Dyalog APL):
 1+∘÷⍣=1
Game of Life (by John Scholes):
 b←1=?30 30⍴2
 {↑1 ⍵∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂⍵}b
== External links ==
* APL Wiki
Category:Implemented 
Category:Languages
Category:Before 1993
Category:Turing complete
Category:APL-like
APLBAONWSJAS

APLBAONWSJAS, or A Programming Language By Any Other Name Would Smell Just As Sweet, is an esoteric programming language designed by User:Vriskanon. It consists of only one command.
== Commands ==
=== Execute ===
Every program consists of a single line of code, EXECUTE(n), where 'n' is the name of a programming language and nothing else. APLBAONWSJAS, upon being run, will run the EXECUTE command and display an interpreter for that programming language. From there, the user must input code manually and then re-run the program, which will run in the executed language. This second-wave programming is considered input in the code, though.
== Example programs ==
=== Python Interpreter ===
EXECUTE(Python)
=== Hello, world! ===
To do this, the Python Interpreter code must be run, followed by the user inputting the following:
print("Hello, world!")
The code for the hello world program is:
EXECUTE(Python)
although there are many ways to produce the hello world program.
=== Cat program ===
 EXECUTE(Text)
== Interpreter ==
=== APLBAONWSJAS Interpreter ===
The following interpreter is written in APLBAONWSJAS:
EXECUTE(APLBAONWSJAS)
===In other languages===
* Python APLBAONWSJAS Interpreter, with intelligent assistant (will run all examples on this page).
Category:Joke languages
Category:Languages
APLWSI

APLWSI (A Programming Language With Smallest Interpreter) is a very simple programming language. Any program on APLWSI does nothing.
== Example programs ==
=== Do nothing ===
This program does nothing
=== Quine ===
=== Self-Interpreter ===
=== Self-Optimizer ===
=== Self-Compiler to brainfuck ===
== Interpreter ==
or any program in any language that does nothing
Here is a bunch of interpreters: APLWSI Interpreters
Category:Joke languages
Category:Total
Category:Languages
Category:Implemented
Category:Unusable for programming
Category:No IO
Category:Nope. derivatives
Category:No-code esolang
ASCII Code

ASCII Code is a esolang made by Mihai Popa. The goal is to fit a program in a ASCII square or rectangle.
== Command list ==
 Command list
Command	Meaning
s 	Sets the current variable. Variable can be any of the 26 letters.
p 	Pushes the character next to it to the variable specified by the s command.
j 	Pushes the number next to it to the variable specified by the s command.
w 	Writes the contents of the variable specified by the s command as a ASCII character.
n 	Writes the contents of the variable specified by the s command as a number.
c 	Clears the variable specified by the s command.
h 	Halts execution.
i 	Stores user input to the variable specified by the s command.
g 	Prints the variable specified by the s command as a string (use with user input).
l 	Adds 2 variables and stores in the variable specified.
m 	Subtracts 2 variables and stores in the variable specified.
q 	Multiples 2 variables and stores in the variable specified.
d 	Divides 2 variables and stores in the variable specified.
f 	If statement, 2 variables (letters) or 2 numbers or a mix in between, execute code in the brackets.
y 	While loop, 2 variables (letters) or 2 numbers or a mix in between, execute code in the brackets.
a 	Start of forever loop.
o 	End of forever loop.
x 	For loop, start, end, step size (optional), execute code in the brackets.
Comments can be done with a percent sign, %, then end with a semicolon ;
Commands are separated by a semicolon.
Values are separated by a space.
It executes from left to right, top to bottom. Also, it's 2D, like in Befunge or Fish.
== Detailed description of the if statement ==
Example:
|---------------------------------|
| % If statement example ; |
| f 3 5 n [s t ; p H ; w ; p i ; |
| w ; p ! ; w ;] ; |
|---------------------------------|
Means if 3 and 5 are not equal, then print "Hi!"
The third value can be one of the following:
e = equal to
n = not equal to
g = greater than
l = less than
q = greater or equal to
s = less or equal to
== Examples ==
=== Hello, world! ===
|---------------------------------|
| % Hello, world! ; |
| % in ASCII Code ; |
| % "p ;" means a space ; |
| |
| s t ; p H ; w ; p e ; w ; p l ; |
| w ; w ; p o ; w ; p , ; w ; |
| p ; w ; p w ; w ; p o ; w ; |
| p r ; w ; p l ; w ; p d ; w ; |
| p ! ; w ; |
| |
| % End of program! ; |
|---------------------------------|
=== Cat ===
|-----------------------|
| % Cat in ASCII Code ; |
| |
| s i ; i ; g ; |
|-----------------------|
=== XKCD Random Number ===
|------------------------|
| % XKCD in ASCII Code ; |
| |
| s n ; p 4 ; w ; |
|------------------------|
=== Truth Machine ===
|------------------------|
| % Truth Machine in ; |
| % ASCII Code ; |
| |
| s t ; i ; f t 0 e [ |
| p 0 ; w ;] ; w t 1 e [ |
| a ; p 1 ; w ; o ;] ; |
|------------------------|
Category:Languages
Category:2025
Category:High-level
Category:Unimplemented
Category:Two-dimensional languages
ASCII art

Is the same as brainfuck except it uses the following art depictions of the symbols (P.S. This could cause very large programs due to the size of these symbols).
\
 \
 /
/
 /
/
\
 \
 |
 |
-----
 |
 |
-----
 ___
|
|
|
|
|___
___
 |
 |
 |
 |
___|
##
##
##
##
_|
==Programs==
(I'm guessing this is how it works)
===Cat Program===
 ##
 ##
 _|
 
 ___
 | 
 | 
 | 
 | 
 |___
 
 ##
 ##
 
 ##
 ##
 _|
 
 ___
 |
 |
 |
 |
 ___|
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages
Category:Joke languages
Category:Brainfuck equivalents
Category:2019
Category:Implemented
Category:Cell-based
Category:Low-level
ASCII art-

ASCII art- (pronounced ASCII art minus) is an ASCII art derivative that uses the commands in ASCII art but replaces them with the single character the commands look like the most.
ASCII art uses, as does ASCII art-, a one dimensional tape memory system that stores integers. There is a pointer which can be manipulated and which can, in turn, manipulate the cells in the tape.
== Commands ==
ASCII art- key	Description
> 	Moves the pointer one to the right.
< 	Moves the pointer one to the left.
+ 	Increments the current cell by one.
- 	Decrements the current cell by one.
[ 	If the current cell is 0, skip to loop end. Otherwise, enter loop.
] 	If the current cell is not 0, skip to the beginning of the loop. Otherwise, exit the loop.
. 	Prints the character of the current cell's ASCII value.
, 	Takes a single character input. The current cell becomes that character's ASCII value.
== Sample Programs ==
=== Hello, World! ===
++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
Category:Languages
Category:Joke languages
Category:Brainfuck equivalents
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Implemented
Category:2015
Category:Brainfuck derivatives
ASCII art/mandelbrot

.;
 '^e ._\
 .b`
 \ vr@d
 "Tm/*""\L/C
 :eF T@,
 _ c . "b, /F` , .
 ^dFLa (@e@bm"*---*"mb@e$b; , a-
 ^.@""bd*"^` '^`#mc:@@e/eF
 '#ec^` '"@ /@ `
 -mLe@*` "@F\
 '-- . ."b/` #F. :,
 --. , -C_ , '@@" \*b@-
 ^"b@(._/@L$L., d@` 'C^`
 '~FL)*^^'^^*@me .@` Fe/
 ., '"m(*` '*e.F @%
 '\,m.v@` 'd` /F`
 , , \/@**#[ \ .d"
-------*)---)----F-*@[ .[ ] '\_
 ^]Fb(#L / "b,
 :F`^ ~@\ /Tc '@e
 -""""e .a@`.b @(,
 -"@L$\mm:mm@@F` @L @"'
 -/FF*' /@`"[ "@e :*me
 ' '\ '##b .F("#;
 -^` dC)e .F@ '
 """`#be .'*me
 :@``m_ ._m@__/@.,
 /_@mdF"#bm__, .._me@)`')*^7`\
 m"Fc' T#`**"#F^`^*CF"*`*F` T`
 ` .)F Tb,
 '\F, ./@\
 -(^"#r(F"'"
 ` "T@"
 _"-_
 'e` ' ^
 '-
Category:Examples
ASCIIfuck

ASCIIfuck is a variation of brainfuck by User:ChuckEsoteric08 which uses ASCII values of a characters.
==Specification==
brainfuck is encoded as follows:
*Take ASCII value of character
*If it has three digits, add first two
*First digit of an operation represents brainfuck command like that:
**1 is +
**2 is -
**3 is >
**4 is <
**5 is ,
**6 is .
**7 is [
**8 is ]
**Anything else is invalid
*Second represents how many times command is repeated.
==Examples==
===Cat===
 3G=3Q
===Hello world===
 eGpyo{eys*Q)p)qQyo=!e= >gG=yQ,=g=t=*o="e=
===brainfuck interpreter (dbfi)===
!eHoQ GoQfyeykG)h f)oGf eyeyiGyfyj*pQe+3)fHyGo Q)G Q*oQ)G)Q)e GyQyG)eyoH)eyoGyG)IoG)Gf)oGymyG)oyoQ Q R*Q)H)QyHyQ G QeG*Q)G)Q)e �QyGyQeGo Q,H*Q)G)Qe*Geye*oGypye*oGye)G e*oSyG)eyoQ)Qf p)GyQ G R*G e)H)Q)QyH*Q)G)QeGo)e oG*eyfyoG)oy*e oS)Gye)oQyQyGyQyQyG Q Q*G e e Q*Go&Q*Gy=%Q*Gyo#Q*Gy3!Q*GyeyQ*Ge*Q)Q
==Interpreter==
* Common Lisp implementation of the ASCIIfuck programming language.
==Convert to ==
*AsciiSquish: Prototype of Lua implementation
Category:Languages Category:Turing complete Category:Brainfuck equivalents Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Turing tarpits Category:Implemented
ASM

ASM is a low-level programming language that functions by replacing strings and never halts until it has nothing to replace. If it reaches the end of a program, it reloads the code until there is nothing to replace.
Programs start out with a ISO-8859-1 character saying how many characters long after this character the command is and then an ISO-8859-1 character with value 0-3. Read below to know what this second character means.
If second char value of command = 3, you have 16 states to work with and a neighborhood size of 2. If second char value of command= 2, you have 8 states and a neighborhood size of 4. If first char value = 1, you have 4 states and a neighborhood size of 8. If second char value of command = 0, you have 2 states and a neighborhood size of 16. 
Programs consist of multiple commands telling the interpreter to replace pair X with pair Y. 
The neighborhoods shift (neighborhood size/2) every even command and then shift back every odd command (except 1). You can have it shift back less than the previous neighborhood size by making a command that does nothing with a neighborhood size that is different. 
The following parts of the commands are first run-length decoded and then you add to the possible pair value X with X mod (possible pairs for command). The same goes with the encoding of a program. This change makes the programs a lot smaller.
I am absolutely certain you can compile Luigi code (including that turing machine program) to this language, which I am working on. 
==Examples==
===Thue-Morse sequence===
This program computes the Thue-Morse sequence. 
code soon
===Infinite loop===
This program executes an infinite loop:
code soon
Category:Low-level 
Category:String-rewriting paradigm
Category:Cell-based 
Category:Languages
Category:2020
Category:Unknown computational class
Category:Unimplemented
Category:No IO
Category:Reversible computing
ASRL?

ASRL? (Another String-Rewriting Language?) is an esolang by User:ChuckEsoteric08 which was inspired by Novice.
==Specification==
ASRL? uses unbouned string as memory. Initial state of it is set to user input. There is three commands:
 !x - declares label
 x=y - if there is instance of x in memory string, replace it with y, else goto label y
 :: - outputs memory string
==Computational class==
ASRL? is Turing-complete because Cyclic Tag interpreter has been written in it:
!-
::
^@=@
@#=#
-=@#
!#
$=$^
-=-
!@
^;=;^
@0='
'=@
-=-
!'
@1=@
-=-
!;^
^0=0^
@1=@1
#=0#
-=-
!@1
-=-
!0^
@1=`
`=@1
#=1#
-=-
!`
-=-
!1^
!$^
!1#
!0#
!@#
Initial string: $^Program@Data#
==See also==
Other string-rewriting languages by ChuckEsoteric08:
*RIfP
*SSREPL
Category:Languages Category:Turing tarpits Category:String-rewriting paradigm Category:Turing complete Category:Unimplemented
AT

AT (also @ or ATlang) is a stack-based functional minimal one-dimensional language created by User:IQBigBang in May 2019.
== Syntax ==
AT language contains two stacks: command-stack and function-stack. As the interpreter moves, everything automatically gets pushed onto the command-stack. Once the interpreter gets to @ character (hence the name of the language), the last item on the command-stack is pushed onto the function-stack (and removed from the command one).
Until the function-stack is not empty again, interpreter sees every character as a function. Functions take arguments from the command-stack and push results back onto it.
== Prebuilt functions ==
function	char 	arguments 	action
print 	p 	whole stack	Prints from the el. stack until it's not empty or the '\0' character is met.
Example 	Example	Example 	Example
Example 	Example	Example 	Example
o (Cycle) - Calls the function with name of last item on the function stack. It keeps calling the function, using other stack items as arguments until the stack is not empty (is used to prevent long lines of repeating one function). Only works with functions that take one argument.
== B64AIF (Integers) ==
B64AIF (Base 64 Ascii Integer Format) is a format used to work with numbers in ATlang. All integers are saved in format
 <prefix><digits>
where the prefix is a digit from 1 to 9 that tells the interpreter how long the number is
The digits are then in Base64 (see https://en.wikipedia.org/wiki/Base64#Base64_table) with incremental order, i.e. the first digit's value is multiplied by one (64^0), the second digit's value is multiplied by 64 (64^1) and so on. 
Example:
 element stack: 2 j f . . .
# The length of the number is 2
# The first (zeroth) digit is j, which corresponds to value 35 * 1 = 35
# The second (first) digit is f, which corresponds to value 31 * 64 = 1984
This number is therefore equal to 2019.
 
== Examples ==
Hello world!
 Hello world!@@@@@@@@@@@@ppppppppppp
Or a shorter version using cycle function:
 pHello World!@@@@@@@@@@@@@o
Category:2019
Category:Languages
Category:Unimplemented
ATSML

ATSML(A Tiny Self-Modifying Language) is a Self-Modifying language by User:ChuckEsoteric08 inprised by SMETANA.
==Commands==
Counting starts at 1
Swap x y	Swaps commands x and y.
Goto x 	Goto command x.
==Computational class==
It is in same computational class as SMETANA because it is SMETANA with diffrent syntax.
==External resources==
Scratch interpreter
Category:Languages Category:Implemented Category:Finite state automata Category:No IO Category:Self-modifying Category:Pseudonatural
ATZ

The ATZ programming language is an esoteric programming language designed by Arvin Zadeh in 2014. It has yet to be implemented and no interpreters have yet been made. Since its development it has been proven to be Turing-complete due to its wide variety of capabilities. On November 12th, 2014, the ATZ programming language was officially proven to be Turing-complete when programmers created a Minsky machine with ATZ code. 
 
 Sample Program #1:
 1st Million Prime Numbers:
 x#isP.T##in=1000000##i=2#[i<=in|#a=2#[a<=i|[?i%a=0|#isP.F#;|#isP.T##a+1#]][?isP|!i!]#i+1#]
 Sample Program #2:
 GCD Function:
 x#gcdOf.func(#a.I##b.I#|[a%b>0|#b-1#]!b!)#
 Sample Program #3:
 Minsky Machine:
 x
 #lineAt=0#
 #incr.func(#reg.I##lineNum.I#|#reg+1##lineAt=lineNum-1#!lineAt!)#
 #decr.func(#reg.I##lineNum1.I##lineNum2.I#|[?reg=0|#lineAt=lineNum1-1#|#reg-1##lineAt=lineNum2-1#]!lineAt!)#
 #i=0##minMac.func(#A.I##B.I##C.I##code.A#|[code!=“halt”|#i=code#])#
 !minMac.func(5,5,nil,{decr(B,4,2),decr(A,3,1),incr(B,4),”halt”})! 
Zadeh says he will release the documentation to the public when the language is ready.
Category:Languages Category:Unimplemented Category:Turing complete
AWA5.0

AWA5.0 is a bubble-based esoteric programming language themed after famous Phase Connect vtuber Jelly Hoshiumi. Temp-Tempai, the hardworking and heartbreakingly handsome creator, got inspired after watching her Shenzhen I/O stream. The purpose of the language is to allow Jelly to write programs in her native language (ex. "Awa awawa awawawa awa awa awawawa awawawawawawa....")
Due to this being a joke that has long outlasted its stay, only a brief description of AWA5.0 will be written here; please see the specification document below for a comprehensive understanding of the language.
==AWA5.0 Structure==
AWA5.0 is based around a FILO, theoretically infinite stack called the Bubble Abyss. The Bubble Abyss contains bubbles, aptly enough. These bubbles can contain either a simple integer value, or any number of other bubbles. As such, bubbles can be infinitely nested within one another.
The Bubble Abyss is interacted with through AWA5.0 commands, called Awatisms. Awatisms are written by AwaTalk encoded 5 bit unsigned integer values, followed by any parameter values also encoded in AwaTalk. AwaTalk is the method of encoding binary data into a string of text that is Jelly-Readable.
Also of note is AwaSCII, a revolutionary 6-bit take on ASCII that allows users of AWA5.0 to read in and print out text to/from the Bubble Abyss.
An AWA5.0 script always starts with an initial "awa", followed by a series of Awatisms. AWA5.0 is case insensitive.
==Example AWA5.0 Script==
The following AWA5.0 script prints "Awa" to the output.
Awatism	Numerical Representation	AwaTalk Representation
blo a 	5 2 	awa awawa awawa awa awa awa awa awa awawa awa
blo w 	5 3 	awa awawa awawa awa awa awa awa awa awawawa
blo A 	5 0 	awa awawa awawa awa awa awa awa awa awa awa awa
srn 3 	9 3 	awawa awa awawa awa awa awawawa awa
prn 	1 	awa awa awa awawa
Final AWA5.0 Code
Awa awa awawa awawa awa awa awa awa awa awawa awa awa awawa awawa awa awa awa awa awa awawawa awa awawa awawa awa awa awa awa awa awa awa awa awawa awa awawa awa awa awawawa awa awa awa awawa
==External Resources==
* AWA5.0 language specification (PDF)
* AWA5.0 Minimal Interpreter
* AWA5.0 Interpreter Source Code
* AWA5.0 Video Tutorial
Category:Languages Category:Implemented Category:Thematic
AWO

AWO or AWOLang is a joke esoteric programming language inspired by Ook!. Scripts are running in the Java virtual machine.
==Hello World==
 AWO: 
 AAWWOO 
 AWOO AWOO AWOO AWOO AWOO AWOO AWOO
 AWO 
 AAWO AAWO AAWO 
 awo
 AWOO AWOO AWOO AWOO AWOO AWOO AWOO 
 awo awo
 AWOO AWOO AWOO
 awo
 
 AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO 
 AWO
 
 AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO 
 AWO
 AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO
 awo
 AWOO AWOO AWOO 
 awo
 AAWO AAWO AAWO AAWO AAWO AAWO 
 awo
 AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO 
 awo
 
 AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO AAWO
 AWO
 AAAWWWOOO
 :AWO
Code formatting does not matter.
==Methods==
Method 	Description
AWO: 	Code start point
:AWO 	Code end point
AAWWOO 	Code end point
AWOO 	Next character
AAWO 	Previous character
AWO 	Submit upper-case char
awo 	Submit lower-case char
AWWO 	Reset char index
AAAWWWOOO	Stop output
==Text output==
Text output works using a character index. It starts by 0 and can be increased and decreased with the methods. 
Category:Joke languages
Category:Low-level
Category: Languages
AZZTURBLICHINORTYEUSIACNOSIPTYRUTIEOSUNEMEEETIRMSPLAORRRRRRRRRRRRRRHSIFUGISSFGIUUUUUUUUUUUUGUIGSEIUFGYUSGNYGNXWGNYX123456789012345678901145141919810TROSHPPAOCONALMELANGUAGE

AZZTURBLICHINORTYEUSIACNOSIPTYRUTIEOSUNEMEEETIRMSPLAORRRRRRRRRRRRRRHSIFUGISSFGIUUUUUUUUUUUUGUIGSEIUFGYUSGNYGNXWGNYX123456789012345678901145141919810TROSHPPAOCONALMELANGUAGE (aka AMONGUSLICHINORTYEUSIACNOSIPTYRUTIEOSUNEMEEETIRMSPLAORRRRRRRRRRRRRRHSIFUGISSFGIUUUUUUUUUUUUGUIGSEIUFGYUSGNYGNXWGNYX123456789012345678901145141919810TROSHPPAOCONALMELANGUAGE) is a language based on Assembly Language.
=== Syntax ===
 Caption text
This language 	Assembly language pseudo-code
GUYS I CAN VOUCH [REGISTER] IS [VALUE] 	mov _register_name, _another_register_name_or_value
I KNOW THAT GUY IS [VALUE such as 0x21] 	int _value
[REGISTER] GOES UP 	add _register, 1(inc _register)
[REGISTER] GOES DOWN 	sub _register, 1(dec _register)
I CAN BELIEVE [SEGMENT_NAME] 	segment_name segment
[SEGMENT_NAME] STOP YOUR PERFORMANCING 	segment_name ends
[REGISTER] GOES IN 	push _register
[REGISTER] GOES OUT 	pop _register
[PART_NAME] GOES IN 	part_name:
[PART_NAME] GOES OUT 	end part_name
[REGISTER] IS THE IMPOSTOR 	cmp _register 0 
je end 
end: mov ax, 4c00h 
int 21h
[REGISTER] CAN VOUCH GO AND TELL THEM COME ON	prn _register
[REGISTER] WHO ARE YOU 	inp _register
[PART_NAME] WALK AROUND THERE ALL TIME 	loop part_name
[REGISTER] GOES INTO [REGISTER OR VALUE] 	add _register, _register_or_value
I SEE [REGISTER] KILLED [REGISTER OR VALUE] 	sub _register, _register_or_value
I GO INTO [PART_NAME] 	jmp part_name
etc. 	etc.
=== Program ===
Some addition
 I CAN BELIEVE CODESG
 _START GOES IN
 GUYS I CAN VOUCH AX IS 0123h
 GUYS I CAN VOUCH BX IS 0456h
 AX GOES INTO BX
 AX GOES INTO AX
 
 GUYS I CAN VOUCH CX IS 0
 CX IS THE IMPOSTOR
 CODESG STOP YOUR PERFORMANCING
 _START GOES OUT
To assembly: 
 assume cs:codesg
 codesg segment
 start: 
 mov ax, 0123H
 mov bx, 0456H
 add ax, bx
 add ax, ax
 
 mov cx, 0
 cmp cx, 0
 je end
 end: 
 mov ax, 4c00H
 int 21H
 codesg ends
 end start
Category:Languages Category:Joke languages Category:Low-level Category:Unimplemented Category:Pseudonatural Category:Sus