nyuuzyou/wikis huggingface dataset:
Mukha

Mukha is one-dimensional esolang by User:ChuckEsoteric08 which is endowed with the faculty of boustrophedon motion across a one-dimensional program, while employing an integer-valued accumulator and a stack of integers for conditionally skipping instructions as well as realizing goto operations.
==Commands==
Command	Operation
+ 	add 1 to the accumulator
- 	subtract 1 from the accumulator. If result was less than zero, skip next command
( 	Push IP to the stack
) 	Pop element from the stack, and set IP to it. If stack was empty do nothing
; 	Pop element from the stack. If stack was empty, skip next command
: 	Go back to the start of the program
> 	move IP to the right
< 	move IP to the left
\ 	if moving left skip next instruction
/ 	if moving right skip next instruction
==Examples==
===Increment and decrement via a loop===
The following program increments the accumulator to the value 3, then repeatedly decrements it in a loop until it reaches a negative state, finally exiting the program.
 +++(-)
===Increment from left to right, decrement from right to left===
This program increments the accumulator to the value 3 while traveling in a sinistrodextral airt, then decrements it to 0 during its athwart traversal.
 +\/-+\/-+\/-<
===Increment accumulator forever===
 >+<
==Interpreter==
* Common Lisp implementation of the Mukha programming language.
Category:Languages Category:Unknown computational class Category:Stack-based Category:Implemented
Multeq

Multeq is an OISC by User:ChuckEsoteric08.
==Command==
 a;b;c;d;
multiply variable a by b and add c, goto 1-indexed command d. If You want to use variable in b, c or d put variable between "%"s.
==Examples==
===Copy value of variable a to variable b===
 b;0;%a%;nextcmd;
Where nextcmd is next command that will be executed.
==External resources==
Compiler to Batch
Category:Languages Category:Implemented Category:OISC Category:Unknown computational class
Multi-Set Manipulator

Multi-Set Manipulator is a set-based programming language invented by User:A inspired by Mathematical Notation. It is not concise at all if it is compared to APL.
== All instructions (in mathematics; this is just copied from the Unicode website) ==
There are 75 symbols in MSM.
All sets in Set Manipulator are multi-sets, although they can occasionally be treated as normal sets.
A∩B A with all items not in B removed; Intersection
A∪B A with all B items appended; Union
AΔB (A-B)∪(B-A)
UA, Unique; make all items in set A unique and return A's value after the unique operation.
^A or ~A or ¯A All items that don't belong to A
A-B A with all B items removed
∅ null set
() Grouping operator
"abcde..." define a set that has 1-byte characters
'a' one character
[1,2,'a'] define a multi-set, allowing numbers.
I The set that results from 1 line of input
O The output set
← initializing
|a| a's absolute value
− Minus sign; subtraction or number negation
√ Square root sign; simply to the power of 1/2.
∛ Cube root; simply to the power of 1/3.
∜ Fourth root; simply to the power of 1/4.
∞ Infinity
a∣b Whether a Divides b
a∤b Whether a does not divide b
∈ ELEMENT OF
∉ NOT AN ELEMENT OF
∋ CONTAINS AS MEMBER
∌ DOES NOT CONTAIN AS MEMBER
¬ not sign
≌ ALL EQUAL TO
∧ LOGICAL AND
∨ LOGICAL OR
÷ Division
× Cartesian product
A new set can be constructed by associating every element of one set with every element of another set. The Cartesian product of two sets A and B, denoted by A × B is the set of all sets {a, b} such that a is a member of A and b is a member of B.
{1, 2} × {1, 2} = {{1, 1}, {1, 2}, {2, 1}, {2, 2}}.
{"a", "b", "c"} × {"d", "e", "f"} = {{"a", "d"}, {"a", "e"}, {"a", "f"}, {"b", "d"}, {"b", "e"}, {"b", "f"}, {"c", "d"}, {"c", "e"}, {"c", "f"}}..
· Multiplication
+ Addition
≼ PRECEDES OR EQUAL TO
≽ SUCCEEDS OR EQUAL TO
≾ PRECEDES OR EQUIVALENT TO
≿ SUCCEEDS OR EQUIVALENT TO
⊂ SUBSET OF
⊃ SUPERSET OF
⊄ NOT A SUBSET OF
⊅ NOT A SUPERSET OF
⊆ SUBSET OF OR EQUAL TO
⊇ SUPERSET OF OR EQUAL TO
⊈ NEITHER A SUBSET OF NOR EQUAL TO
⊉ NEITHER A SUPERSET OF NOR EQUAL TO
⊊ SUBSET OF WITH NOT EQUAL TO
⊋ SUPERSET OF WITH NOT EQUAL TO
⊀ DOES NOT PRECEDE
⊁ DOES NOT SUCCEED
≠ NOT EQUAL TO
= equals sign; compares both values and multi-sets
< Less than
> Greater than
≤ LESS-THAN OR EQUAL TO
≥ GREATER-THAN OR EQUAL TO
≬ Between
≭ NOT EQUIVALENT TO
≲ LESS-THAN OR EQUIVALENT TO
≳ GREATER-THAN OR EQUIVALENT TO
≴ NEITHER LESS-THAN NOR EQUIVALENT TO
≵ NEITHER GREATER-THAN NOR EQUIVALENT TO
≺ PRECEDES
≻ SUCCEEDS
⊻ XOR
⊼ NAND
⊽ NOR
⊭ NOT TRUE
⊨ TRUE
∴ THEREFORE
∵ BECAUSE; part of an if statement such as ∵condition∴action
⋠ DOES NOT PRECEDE OR EQUAL
⋡ DOES NOT SUCCEED OR EQUAL
==See also==
* Multi-Set Manipulator/Smaller
Category:2019
Category:Languages
Category:Unimplemented
Multi-Set Manipulator/Smaller

(Invented by User:A)All sets in Set Manipulator are multi-sets, although they can occasionally be treated as normal sets.
==Set-manipulational instructions==
A∩B A with all items not in B removed; Intersection
A∪B A with all B items appended; Union
AΔB (A-B)∪(B-A)
A\B A with all B items removed
() Grouping operator
"S" Someting that is not a set; it will be converted to a set automatically.
[1,2,"a","etc"] standard way of defining a multi-set, allowing numbers (as in Python). a is a name here if all of its characters are in lowercase.
i The set that results from 1 line of input; all results of each line are outputted by default.
@i length of i
==Set-comparison instructions==
∈ ELEMENT OF
∉ NOT AN ELEMENT OF
∋ CONTAINS AS MEMBER
∌ DOES NOT CONTAIN AS MEMBER
⊂ STRICT SUBSET OF
⊃ STRICT SUPERSET OF
⊄ NOT A SUBSET OF
⊅ NOT A SUPERSET OF
⊆ SUBSET OF OR EQUAL TO
⊇ SUPERSET OF OR EQUAL TO
==Built-in Sets==
I Positive integers
Z Integers {…-3,-2,-1,0,1,2,3,…}
P All prime numbers {2, 3, 5, 7, 11, 13, 17, …}
∅ null set
==Integer comparision instructions==
≠ NOT EQUAL TO; compares both values and multi-sets 
= equals sign; compares both values and multi-sets
< Less than
> Greater than
≤ LESS-THAN OR EQUAL TO
≥ GREATER-THAN OR EQUAL TO
a∣b Whether a Divides b
a∤b Whether a does not divide b
==Logical instructions==
⊻ XOR
⊼ NAND
⊽ NOR
∧ LOGICAL AND
∨ LOGICAL OR
¬ not sign
⊭ NOT TRUE
⊨ TRUE
==Integer manipulational instructions==
÷ Division
· Multiplication
+ Addition
- Subtraction
==Proof as a programming language==
===Primality checker===
i∈P
===Unary Adder===
i∪i
==Exchange "Good" and "Bad"==
"Goodbad"/i
==See also==
* Multi-Set Manipulator
Category:2019
Category:Languages
Category:Unimplemented
Multi-Set Manipulator/String

This is a string-based version of Multi-Set Manipulator/Subset, as there are programming difficulties for using lists.
This attempts to make Multi-Set Manipulator a pure set-based language. All sets in Set Manipulator are multi-sets, although they can occasionally be treated as normal sets.
==Set-manipulational instructions==
A∩B A with all items not in B removed; Intersection
A∪B A appended with B; Union
«I Make the I set's items exclusive.
AΔB (A-B)∪(B-A)
A\B A with all B items removed
"ABC" Define a set
I The set that results from 1 line of input; all expressions are outputted by default.
← Initializement; for all of the undefined variables it searches for where that variable is in the program and then evaluates that variable's expression first. The initialized value will be returned.
= Equivalency symbol
¶ Separate lines
∴ expression∴action; conditional statement
==Set-comparison instructions==
∈ ELEMENT OF
∉ NOT AN ELEMENT OF
⊂ STRICT SUBSET OF
⊆ SUBSET OF OR EQUAL TO
==Built-in sets==
Z Is the set a positive integer? "\x01\x02\x03\x04\x05\x06..."
P Prime number set; "\x02\x03\x05\x07\x0B\x0D..."
∅ Null set; ""
U Universal set; "\x00\x01...\xFE\xFF"
==Proof as a programming language==
===Primality checker===
I∈P
===Unary Adder===
I∪I
==Exchange "Good" and "Bad"==
"GoodBad"\I
==Output with the same length as the code==
A←"aaaa"¶A∪A
==Create output twice the length as the code==
It is impossible... here is an approximate one.
A←"aaaa"¶A∪A∪A∪A∪A∪A∪A∪A∪A∪A∪A∪A∪A∪A∪A∪A∪A∪A
==Shortest code to produce infinite output==
A←"H"∪A
==Is it double speak?==
A←I=A\«A
==Code page==
 _0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F
0_ ∩ ∪ « Δ \ " ← = ¶ ∈ ∉ ⊂ ⊆ ∅ Z P
1_ A I U E ∴
Category:2019
Category:Languages
Category:Unimplemented
Multi-Set Manipulator/Subset

User:A attempts to make Multi-Set Manipulator a pure set-based language. All sets in Set Manipulator are multi-sets, although they can occasionally be treated as normal sets.
==Set-manipulational instructions==
A∩B A with all items not in B removed; Intersection
A∪B A with all B items appended; Union
AΔB (A-B)∪(B-A)
^A or ~A or ¯A All items that don't belong to A
A-B or A\B A with all B items removed
|a| a's absolute value; if a is a set, returns the length of the set a.
() Grouping operator
"abcde..." define a set that has 1-byte characters
"a" one-character multi-set
{1,2,"a"} define a multi-set, allowing numbers.
I The set that results from 1 line of input; all expressions are outputted by default.
← initializing
==Set-comparison instructions==
∈ ELEMENT OF
∉ NOT AN ELEMENT OF
∋ CONTAINS AS MEMBER
∌ DOES NOT CONTAIN AS MEMBER
⊂ STRICT SUBSET OF
⊃ STRICT SUPERSET OF
⊄ NOT A SUBSET OF
⊅ NOT A SUPERSET OF
⊆ SUBSET OF OR EQUAL TO
⊇ SUPERSET OF OR EQUAL TO
==Integer comparision instructions==
≠ NOT EQUAL TO; compares both values and multi-sets 
= equals sign; compares both values and multi-sets
< Less than
> Greater than
≤ LESS-THAN OR EQUAL TO
≥ GREATER-THAN OR EQUAL TO
a∣b Whether a Divides b
a∤b Whether a does not divide b
==Logical instructions==
⊻ XOR
⊼ NAND
⊽ NOR
∧ LOGICAL AND
∨ LOGICAL OR
¬ not sign
⊭ NOT TRUE
⊨ TRUE
==Integer manipulational instructions==
÷ Division
· Multiplication
+ Addition
==Miscellaneous instructions==
… Eclipsis to describe an obvious pattern
: Such that, used to describe a set
==Built-in Sets==
N Natural numbers
N* or N+ Positive integers
Z Integers {…-3,-2,-1,0,1,2,3,…}
Q：Rational numbers; {a÷b:a,b∈Z∧b≠0}; All integers can be represented as a÷1.
Q+ Positive rational numbers
Q- Negative rational numbers
R Set of real numbers
R+ Positive real numbers
R- Negative real numbers
C Composite numbers {a + bi:a, b ∈ R}
P All prime numbers {2, 3, 5, 7, 11, 13, 17, …}
Ñ All quaternions; {a + bi + cj + dk:a, b, c, d ∈ R}
T All transcendental numbers
U Universal set
∅ null set
Square root functions are unneccecary, because:
√ Square root sign; simply to the power of 1÷2.
∛ Cube root; simply to the power of 1÷3.
∜ Fourth root; simply to the power of 1÷4.
== Set descriptions ==
ans←(a∩b)∪(b∩c)∪(c∩a)
O←O∪"Hello, world!"
Max function and Min function
(a+b+|a-b|)÷2
(a+b-|a-b|)÷2
== Natural numbers set not using the built-in N ==
N←{n:n>0∧n∣1}
== Cartesian product ==
A × B ← {{a,b} : a∈A∧b∈B}
== The set F of the twenty smallest integers that are four less than a perfect square ==
F←{n2-4:n∈Z∧0≤n≤19}
== Average of all numbers in a set ==
(A0+A1+...+A|A|)÷|A|
== All prime numbers less than I ==
T←{n:n∈R∧n≤I}
==Proof as a programming language==
===Primality checker===
I∈P
===Unary Adder===
I∪I
Category:Before 1993
Category:Languages
Category:Unimplemented
Multi-machine

A Multi-machine is an extremely simple program type invented bt User:A to check decision, looping, addition, subtraction, termination, input, and output in a simpler way compared to Truth-machine.
==Concept==
Rules:
*Never use a for loop.
The process, expressed in pseudocode, constitutes:
 a ← input integer, where a ∈ ℤ
 b ← input integer, where b ∈ ℤ ∧ b ≥ 0
 c ← 0, where c ∈ ℤ
 
 while b ≠ 0 do
 print c
 c ← c + a
 b ← b - 1
 end while
 
 print c
 terminate program
==Variants==
In languages without input capabilities, the input should be placed somewhere in the code or in the memory.
In languages without output capabilities, the result should be saved in the memory, or even somewhere in the code.
==Implementations==
An exemplary implementation in Common Lisp resolves to this:
 (let ((a (parse-integer (read-line)))
 (b (parse-integer (read-line)))
 (c 0))
 (declare (type (integer * *) a))
 (declare (type (integer 0 *) b))
 (declare (type (integer * *) c))
 
 (loop until (zerop b) do
 (format T "~&~d" c)
 (incf c a)
 (decf b 1))
 
 (format T "~&~d" c))
==See also==
* Mirror-machine, a conceptually similar type of program
* Truth-machine, a conceptually similar type of program which employs infinite loops
Category:2018 Category: Program forms
MultiBrain

MultiBrain is a brainf derivative that uses multiple brainf programs and tapes
= New Stuff =
== Multi-Tape Operations ==
=== Add Tape ===
Adds a new tape "*"
=== Remove Tape ===
Removes the previously added tape that still exists "/"
=== Next Tape ===
Goes to the next tape ")"
=== Previous Tape ===
Goes to the previous tape "("
=== Save Current Cell ===
Saves the current cell ":"
=== Load Saved Cell ===
Loads the saved cell ";" into the current cell
== Multi-Program Operations ==
=== Add Program ===
Adds a new program "~"
=== Remove Program ===
Removes the previously added program that still exists "`"
=== Next Program ===
Goes to the next program "}"
=== Previous Program ===
Goes to the previous program "{"
=== Run Current Program ===
Runs current program "|"
=== Write Character To Next Program ===
Writes current cell as a character into next program "="
=== Write Character To Previous Program ===
Writes current cell as a character into previous program "_"
Category:Languages
Category:Brainfuck derivatives
Multiline

A eso-lang made by User:Zenenbee that is based off of one of their eso-lang, OneLine in which both are based off of Brainfuck
==Commands==
Command 	Description
print() 	Prints a value
count() 	Increases the count by the value
[Loop] id 	Starts or ends a loop as the id
printcount()	Prints current count as ASCII code
pushstack() 	Adds current count as ASCII code to string
readstack() 	Reads ASCII count stack
cursor() 	Moves cursor by value
==Examples==
===Hello, World!===
print("Hello World!")
==External resources==
===Interpreters in Python===
* MultiLine is the main interpreter created by Zenenbee
Category:2020 Category:Implemented Category:Languages
Multiply

The Multiply esoteric programming language is inspired by User:A's math homework. The math homework requires me to represent values using -3, -2, and -1 by multiplying them or dividing them. (I did not use division, though.)
==Syntax==
This programming language only implements multiplication.
It uses only 3 values: x as -3, y as -2, and z as -1.
Whitespace means multiplication.
==Examples==
 x y y z <-- -3*-2*-2*-1=12.
Or in a condensed form:
 xyyz
In a readable form:
 x*y*y*z
Another program that prints -24:
 x y y y z <-- -3*-2*-2*-2*-1=-24.
=== XKCD Random Number ===
 Chosen by fair dice roll
 Guaranteed to be random!
 why.
==Implementation==
This is an interpreter made in C:
#include <stdio.h>
int main(int argc, char *argv[])
{
	int ac=1;
	char c;
	FILE *fp=fopen(argv[1],"r");
	for(;(c=fgetc(fp))!=EOF;)
	{
		if(c=='x')
			ac*=-3;
		else if(c=='y')
			ac*=-2;
		else if(c=='z')
			ac*=-1;
	}
	printf("%d\n",ac);
	return 0;
}
==See also==
* V2
Category:Languages
Category:2019
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:Total
Category:Finite state automata
Multiply/V2

:
Multiply but with binary conversion.
==Python Intepreter==
def binaryToDecimal(n):
 return int(n,2)
def decimalToBinary(n):
 return bin(n).replace("0b","")
def intepret(code):
 ac=1
 t="int"
 for c in code:
 if c == 'x':
 if t == "bin":
 ac = binaryToDecimal(ac)
 ac*=-3
 if t == "bin":
 ac = decimalToBinary(ac)
 elif c == 'y':
 if t == "bin":
 ac = binaryToDecimal(ac)
 ac*=-2
 if t == "bin":
 ac = decimalToBinary(ac)
 elif c == 'z':
 if t == "bin":
 ac = binaryToDecimal(ac)
 ac*=-1
 if t == "bin":
 ac = decimalToBinary(ac)
 elif c == "c":
 if t == "int":
 ac = decimalToBinary(ac)
 t="bin"
 elif t == "bin":
 ac = binaryToDecimal(ac)
 t="int"
 if t == "bin":
 if ac[0] == "-":
 ac = "-0b" + ac[1:]
 else:
 ac = "0b" + ac
 input(ac)
intepret(input(">>> "))
==See also==
* Multiply
Category:Languages Category:Implemented Category:Implementations
Multiprocessing

Multiprocessing, or MP is an esolang created by User:None1.
==Commands==
There is only one command: *, which starts the program in a separate process, all other characters are NOPs.
==Example Programs==
===Fork Bomb===
 **
The program executes itself recursively until your computer crashes.
==Interpreters==
===Python===
The interpreter only supports Windows
import os,sys
c=input()
for i in c:
 if i=='*':
 os.system('start '+sys.executable+' '+sys.argv[0])
Category:Languages
Category:Joke languages
Category:Implemented
Category:Unusable for programming
Multiprogramming

Multiprogramming refers to the practice of executing the same portion of code in multiple different non-trivial contexts. What makes a context "non-trivial" is not well defined, but it generally excludes executing the same portion of code in merely a different state (i.e. a different set of values in global variables.)
A classic example of multiprogramming is executing the same code in a different direction in a multidirectional language such as Befunge or SNUSP.
This term should not be confused with the non-esoteric meaning of the word, usually used in operating systems circles, where it means something closer to concurrent programming. A more precise definition is given on .
Category: Programming techniques
Multleq

Multleq(Multiply, add and jump if less or equal to) is an OISC by User:ChuckEsoteric08 which uses self-modifying code.
==Command==
 a b c d e
memory address a multiplied by memory address b and incremented by memory address c, storing result in memory address a and if result was less or equal to memory address d, goto memory address e.
Note that every memory address that does not exist is always zero
==Assembly-like language==
Copy a to b:
 COP a, b, d, e:
 b Z a d e
Where 'Z' is value that is zero
Set a to 0
 CLEAR a, d, e:
 a Z Z d e
Jump unconditionally:
 JMP a:
 Z Z Z Z a
Category:Languages Category:Turing complete Category:OISC Category:Turing tarpits Category:No IO
Muriel/compile from minsky machine

This python program compiles Minsky machine program into Muriel program.(Using state 0 means halt, and the program starts from state 1.)
program='''
inc a 2
inc a 3
inc a 4
inc b 5
dec a 4 0
'''
def r(s):
 return (s.replace("\\","\\\\")
 .replace("\"","\\\"")
 .replace('\n','\\n'))
def compile(program):
 p=[[x for x in x.split(' ')
 if x in{'inc','dec','a','b'}or x.isdigit()]
 for x in program.split('\n')if x!=]
 d='0';e='0';f='0';g='0';h='0'
 i=1
 for x in p:
 if(x[0],x[1])==('inc','a'):
 d+=f'+(c={i})'
 h+=f'+({x[2]}*(c={i}))'
 if(x[0],x[1])==('inc','b'):
 f+=f'+(c={i})'
 h+=f'+({x[2]}*(c={i}))'
 if(x[0],x[1])==('dec','a'):
 e+=f'+((c={i})*(a>0))'
 h+=f'+((({x[2]}*(a>0))+(({x[3]})*(a=0)))*(c={i}))'
 if(x[0],x[1])==('dec','b'):
 g+=f'+((c={i})*(b>0))'
 h+=f'+((({x[2]}*(b>0))+(({x[3]})*(b=0)))*(c={i}))'
 i+=1
 res=f'a:0;b:0;c:1;d:{d};e:{e};f:{f};g:{g};h:{h};\n'
 res+=f'D:"d:{d};";\nE:"e:{e};";\nF:"f:{f};";\nG:"g:{g};";\nH:"h:{h};";\n'
 res+=r'L:"a:"+$a+";b:"+$b+";.\"a:\"+$a+\"\\nb:\"+$b";'+'\n'
 R=r'"S:\""+|S+"\";\na:"+$(a+d-e)+";b:"+$(b+f-g)+";c:"+$h+";"+D+E+F+G+H+"\nD:\""+D+"\";\nE:\""+E+"\";\nF:\""+F+"\";\nG:\""+G+"\";\nH:\""+H+"\";\nL:"+"\"a:\"+$a+\";b:\"+$b+\";.\\\"a:\\\"+$a+\\\"\\\\nb:\\\"+$b\";\nR:"+S+";\n@(%L,0,&L*(c=0))+(%R,0,&R*(c>0))"'
 res+='R:'+R+';\n'
 res+='@(%L,0,&L*(c=0))+(%R,0,&R*(c>0))'
 S=f'S:"{r(R)}";\n'
 res=S+res
 return res
print(compile(program))
For this example, the output will be:
S:"\"S:\\\"\"+|S+\"\\\";\\na:\"+$(a+d-e)+\";b:\"+$(b+f-g)+\";c:\"+$h+\";\"+D+E+F+G+H+\"\\nD:\\\"\"+D+\"\\\";\\nE:\\\"\"+E+\"\\\";\\nF:\\\"\"+F+\"\\\";\\nG:\\\"\"+G+\"\\\";\\nH:\\\"\"+H+\"\\\";\\nL:\"+\"\\\"a:\\\"+$a+\\\";b:\\\"+$b+\\\";.\\\\\\\"a:\\\\\\\"+$a+\\\\\\\"\\\\\\\\nb:\\\\\\\"+$b\\\";\\nR:\"+S+\";\\n@(%L,0,&L*(c=0))+(%R,0,&R*(c>0))\"";
a:0;b:0;c:1;d:0+(c=1)+(c=2)+(c=3);e:0+((c=5)*(a>0));f:0+(c=4);g:0;h:0+(2*(c=1))+(3*(c=2))+(4*(c=3))+(5*(c=4))+(((4*(a>0))+((0)*(a=0)))*(c=5));
D:"d:0+(c=1)+(c=2)+(c=3);";
E:"e:0+((c=5)*(a>0));";
F:"f:0+(c=4);";
G:"g:0;";
H:"h:0+(2*(c=1))+(3*(c=2))+(4*(c=3))+(5*(c=4))+(((4*(a>0))+((0)*(a=0)))*(c=5));";
L:"a:"+$a+";b:"+$b+";.\"a:\"+$a+\"\\nb:\"+$b";
R:"S:\""+|S+"\";\na:"+$(a+d-e)+";b:"+$(b+f-g)+";c:"+$h+";"+D+E+F+G+H+"\nD:\""+D+"\";\nE:\""+E+"\";\nF:\""+F+"\";\nG:\""+G+"\";\nH:\""+H+"\";\nL:"+"\"a:\"+$a+\";b:\"+$b+\";.\\\"a:\\\"+$a+\\\"\\\\nb:\\\"+$b\";\nR:"+S+";\n@(%L,0,&L*(c=0))+(%R,0,&R*(c>0))";
@(%L,0,&L*(c=0))+(%R,0,&R*(c>0))
And the output of this Muriel program will be:
a:0
b:4
by User:Jan jelo
Mushy! :3

Mushy! :3 is an esolanguage that fits in a mushroom :D
==Commands==
 q - Move pointer right
 e - Move pointer left
 w - Increment cell pointed to by 1
 s - Decrement cell pointed to by 1
 t - Increment cell pointed to by 10
 g - Decrement cell pointed to by 10
 p - Print cell pointed to's alphabet correspondance
 o - Save user input to cell pointed to
 n - Skip to corresponding "m" if cell pointed to is 0.
 m - Skip to corresponding "n" if cell pointed to is nonzero.
==Format==
You know how you can shape Branflakes? You have to shape Mushy! :3 code in a mushroom shape.
==Hello World==
Raw:
 tsspsssptsssppwwwpqttwwwpepwwwpqqtwpqwwww
Mushroom (Proper Format):
 tsspssspt
 sssppwwwpqtt
 wwwpepwww
 p
 q
 q
 t
 w
 p
 q
 w
 w
 w
 w
Category:Languages Category:Cell-based
Musical-X

Musical-X is an esoteric programming language whose source code consists entirely of music, invented by User:Zzo38.
You can only play one note at a time and rests are ignored. The first note indicates what key it is written in (it must be a major key). The commands exist between every 2 adjacent notes and depend on the interval between them, compound intervals are the same as simple intervals, and they are all considered to be notes in the major key (if they aren't, both the first and second note of the command are rounded up, so that you can play minor keys as well if you prefer). Unisons or octaves (simple or compound) are ignored as if they were only a single note, rather than two equivalent notes.
There are many infinite tapes as in Brainfuck with values 0-255, each tape has a separate pointer, and each tape is named with one note. The initial tape is the note at the beginning of the program.
Commands 	Commands
2nd up 	Increment value at pointer (mod 256).
2nd down 	Decrement value at pointer (mod 256).
3rd up 	Move tape pointer one space forward.
3rd down 	Move tape pointer one space backward.
4th up 	Input value at pointer.
4th down 	Output value at pointer.
5th up 	Select tape indicated by second note.
5th down 	Move to initial position of current tape.
6th up 	If value at pointer is non-zero, then search backward to command with a first note the same note as the second note of this command.
6th down 	If value at pointer is zero, then search forward to command with a first note the same note as the first note of this command.
7th up 	Interpret next command as in Auxiliary list #1.
7th down 	Change key to the second note of this command.
Auxiliary list #1	Auxiliary list #1
2nd up 	Increase value at pointer by 64 (mod 256).
2nd down 	Decrease value at pointer by 64 (mod 256).
3rd up 	Move tape pointer 64 spaces forward.
3rd down 	Move tape pointer 64 spaces backward.
4th up 	Change notes not of this key to round up instead of down.
4th down 	Change notes not of this key to round down instead of up.
5th up 	Select tape indicated by first note.
5th down 	Skip next command.
6th up 	If value at pointer is even, then search backward to command with a first note the same note as the second note of this command.
6th down 	If value at pointer is odd, then search forward to command with a first note the same note as the first note of this command.
7th up 	(RESERVED)
7th down 	(RESERVED)
==Examples==
(Note: These examples are given using the PLAY syntax in QBASIC.)
Program to copy input to output until chr(0):
 "l8mlo2c16p16c16f.<a-16e-.a-16>fl32e-<e->e-<e->e-<e->e-<e->"
Category:Languages Category:2007
Category:Non-textual
== See also ==
Musical notes, another esolang based on music.