nyuuzyou/wikis huggingface dataset:
Saturnus

Saturnus, while technically not an esolang, is a programming language that aims to have a simplified mix of Rust programming language and Lua.
The main target for Saturnus compiler is Lua, but multi-target compilation will arrive in the future, so stay tuned if you like the language.
The original purpose of this language was to provide an easy-to-learn syntax, and fast compilation times, to replace Lua scripts.
== Examples ==
 // Variables are easy stuff in Saturnus:
 let a = "be something";
 // period.
=== Operators ===
 // Addition is more idiomatic than in plain Lua syntax:
 count += 1;
 strcat ++= "foo'd";
 // Basic operators include + - * / ** % and ++ (String concat)
 let a = b + c;
=== Classes ===
 // Basic OOP
 class Foo {
 fn new() {
 return Foo {};
 }
 fn greet(self) {
 print("Hello world!");
 }
 }
 // Note the differences between dispatch types
 let instance = Foo.new();
 instance->greet();
=== Collections ===
 // Collection types:
 let this_is_a_table = { a, b: "foo", c: 30-30 };
 let this_is_a_vector = [1, 2, 3, (), "potato"];
 let this_is_a_tuple = ("foo", 10, "bar");
=== Loops ===
 // The basic loop!
 // Will repeat as long as the expression between "while" and "do" words is
 // true-like (Can evaluate to "true").
 while something() {
 print("Something is true!");
 }
 // This one is a sugar syntax introduced by Saturnus!
 // Imagine you want to loop as long as you have a result that is not null, you
 // could use iterators, reserve your own local variables and such, but we
 // have a more idiomatic syntax sugar for you:
 while let some = thing() {
 // The "some" variable is only visible within the loop, and you know that
 // will be a true-ish value (Like 1, true or something not null).
 print("Some is " ++ some);
 }
 // Numeric for? Easy:
 for i in 1..10 {
 print("i = " ++ i)
 }
 // Now, the classical foreach:
 for entry in entries() {
 print(entry._0 ++ " = " ++ entry._1);
 }
 // Note: This is a raw iterator loop, and cannot be used in place of an
 // iterator! This means that is no replacement for pairs function (and also
 // it does NOT work well with it...)
 // This assumes that what you have between "in" and "do" returns an iterator
 // of a single entry value.
 // To transform collections to iterators, you will need some prelude functions.
 // And the final, the simplest and the dumbest:
 loop {
 print("I'm looping forever...");
 if should_exit() {
 print("Or I am?");
 return true;
 }
 }
 // Note: Has no exit condition, you will have to either "break" or "return"!
== External resources ==
* Github project page
Category:Languages Category:Implemented Category:High-level
Savage Operator

Savage Operator is a esolang created by User:Yayimhere inspired by Unlambda. as it was developed it became more focused on creating the actual lambdas and less about using the actual operators. so it becomes more like Action symbol
== syntax form ==
a operator is applied with Prefix notation like in Unlambda and brackets around a string e:
 (e)
== operators ==
some of these are represented with Lambda calculus expressions. also all these expressions have input x, and if there is a second input that is y:
* e : a lambda expression with no body. can't be the final result nor be applied to something
* v : λx.v
* E : λx.x (λx. ) which can also not be the final result
* i : λx.x
* ε : λx.ε x
* w : (λx.(x))
* ∞ : evaluate x
* ∞' : evaluate x for a single iteration
* a : λx.λy.x y without evaluating it
* a' : a but goes into brackets, without evaluating it
* b' : a' but prepend
* d : rename all instances of x(including in input) in expression y as z
* [(x)(y)(z)] : x=λz.y or x=y if z is empty
=== exclusions ===
* ∞ and ∞' cant be applied to: [(x)(y)(z)], e, and E
* b', a', d, and a cant be applied to: ∞, ∞', a', b', [(x)(y)(z)], d
== Turing-completeness ==
Savage Operator is turing complete since we can define SKI combinator calculus operators:
 [(S)(a’ (a’ (w (a g x) ) (a f x) (a’ (d x e f) (d x e g))) )(f)]
 [(K)(a’ (d x e y) y)(x)]
 and I is just... i
now any expression in SKI calculus is valid in Savage operator. these work by creating functions that are equal to the S and K operators
so the needed commands are 
Category:Languages Category:2024 Category:Functional paradigm Category:Unimplemented Category:Unknown computational class
Say

==Syntax==
Things in square brackets are optional, but if one is given, the others most be given too.
 Variable: "[Yes/No, ]Variable2, it is Value[, not String]"
Value can be:
* A string (surrounded by single quotes), then the string is stored into Variable2
* A number, if it is i, then the i-th line (1-indexed) is jumped
* what you think it is reads input as a string and stores the input into Variable2
* what you think it is not prints Variable2
If the thing in the brackets are given, the line is only executed if String==Variable2 if the word is Yes, and String!=Variable2 if the word is No.
Reading nonexistent variables result in empty strings, variables only exist when they are modified.
==Examples==
===Hello, World!===
 A: "X, it is 'Hello, World!'"
 A: "A, it is what you think it is not"
===Cat program===
 A: "A, it is what you think it is"
 A: "A, it is what you think it is not"
===Truth Machine===
 A: "A, it is what you think it is"
 A: "A, it is what you think it is not"
 A: "No, A, it is 2, not '0'"
Category:Languages
Category:Pseudonatural
Category:2024
Category:Unusable for programming
Category:Unimplemented
Scan

Scan is a toy programming language. I, User:b_jonas created it in 2003. I published it to the world around 2006.
Scan is dynamically typed, values can be integer, null value, and first-class function. The language has lambda expressions, but lambda expressions cannot take any arguments, so you must pass arguments in global variables. There are a few builtin functions, and these can take arguments. Local variables exist, but lexical closures aren't handled properly, function values don't actually close over anything. The interpreter has other known bugs. Arrays aren't supported.
The interpreter is implemented in old C++ and a tokenizer in flex. The interpreter builds a parse tree and then executes it. The interpreter can be ran in interactive mode, in which case it executes each complete top-level statement as soon as it's read one.
I wrote the interpreter for a university programming course. However, the teacher complained that writing a yacc parser is part of the requirements, so I subsequently wrote a second interpreter called geo to satisfy his request.
== External resources ==
Interpreter source code
Category:Languages
Category:2003
Category:Push-down automata
Category:Output only
Category:Implemented
Sceql

Sceql is an esoteric programming language devised by Scott Feeney in 2005, which provides a single byte queue as the only form of memory available to programs. The queue can never be empty, and data can never be removed from it once enqueued into it. Initially the queue has one value of 0.
Sceql was originally intended as a revised version of Qdeql with an easier to use and more practical instruction set, but with the additional challenge of a queue that grows indefinitely and never shrinks.
==Instructions==
Instruction	Instruction	Description
= 	NEXT 	Dequeue a byte and enqueue it again
- 	DEC 	Decrement the byte that would be dequeued next (wrapping)
_ 	INC 	Increment the byte that would be dequeued next (wrapping)
\ 	BEGIN 	Skip to the instruction after the corresponding END if the byte that would be dequeued next is zero
/ 	END 	Go back to the corresponding BEGIN
! 	GROW 	Enqueue a new zero byte
& 	INPUT 	Read a byte from stdin and enqueue it (0 for EOF)
* 	OUTPUT 	Dequeue a byte, write it to stdout, and enqueue it again
==Example programs==
===Hello, World!===
This program will print the string "Hello, World!" followed by a newline. Every line of the program corresponds to one character; the queue eventually will contain three bytes, one used for H, e, l, o, W, r and d, one for the comma, space and exclamation mark, and one for the newline.
 ________________________________________________________________________*
 _____________________________*
 _______*
 *
 ___*
 !=____________________________________________*
 =------------*
 ________*
 =--------*
 =___*
 =------*
 =--------*
 _*
 !==__________*
===Cat program===
 -&=\&*_\-=_/-=/
In clear text, with the state of the queue in comments (assuming everything which is not an instruction is ignored):
 [0]
 DEC INPUT NEXT
 [first 255]
 BEGIN while not eof
 [prev ... 255]
 INPUT
 OUTPUT
 [... 255 curr prev]
 INC BEGIN while not 255
 DEC NEXT INC
 END DEC
 NEXT
 [curr ... 255]
 END
==Computational class==
Sceql is Turing-complete. See Sceql Turing-completeness proof for more information.
==See also==
* Qdeql
==External resources==
* Sceql interpreter in C
* 99 bottles of beer and quine in Sceql
* Brainfuck to Sceql translator
Category:Languages
Category:Queue-based
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2005
Schacalic

Schacalic, or ʂaʧʰɑlɪkʰ, is based on PLUSHIES ART.
== Syntax ==
Same as PLUSHIES ART.
== Examples ==
=== Hello, world! ===
print("Hello, world!")
=== Cat program ===
print(x) where:
 x = str(input(__prompt = "Please input: "))
=== Pseudo-Truth machine(?) ===
if x then:
{
 while True:
 {
 print(x, end = "\n")
 }
}
else:
{
 print(x)
 exit(0)
}
where:
 x = bool(input(__prompt = ""))
=== Script in Logo of PLUSHIES ART ===
var1 = input()
dump(ans1, var1)
print(x)
dump(ans1, x)
--snip--
=== OTHER ===
啊啊啊啊啊、啊！啊啊啊、啊啊啊啊、啊啊、啊！啊啊、啊啊啊、啊啊啊啊啊，啊！啊啊啊、啊啊、啊！啊啊、啊啊啊啊、啊啊！
== Categories ==
Category:Languages
School

School is an esoteric programming language developed by User:AceKiron, it originally started development on June 15th 2021, but has been deprecated. Later it was continued on September 10th 2021. It's designed to be hard to understand why, just like school.
Origianlly school was stack-based, meaning it used a stack to store memory. The renewed version of School is supposed to instead use a matrix with a size of 5.
== Source code ==
School is open source, its interpreter's source code can be found on https://github.com/AceKiron/School .
== Datatypes ==
The datatypes are represented as the following numbers:
Datatype 	Representation	Minimum interpreter version
Compound 	0 	1.0.0
RegularFunction	1 	1.0.0
DollarFunction 	2 	1.0.0
NOOP 	3 	1.0.0
Number 	4 	1.0.0
String 	5 	1.0.1We're still testing this interpeter.
== Matrix operants ==
Operation 	Meaning 	Minimum interpreter version
PEEK(?x) 	Returns the value of the location from the top row if specified, otherwise it returns a random value from the top row. 	1.0.0
DROP() 	Moves the whole matrix down by 1 unit, doesn't get wrapped around. 	1.0.0
ROTATE() 	Rotates the matrix clockwise by 90°. 	1.0.0
COUNT(?row) 	Counts all items in the matrix, unless row is specified in which case it counts all the items in that row. 	1.0.0
PUSH(value, x)	Pushes a single value onto the top row of the matrix, if a value already exists in given position, the original value will be removed.	1.0.0
POP(?x) 	Pops the top row of the memory matrix, unless x is specified in which case it pops and returns a single value from the top row. 	1.0.0
TYPE(x) 	Returns the type of the value at x in the top row represented as a number. 	1.0.1
GRAVITATE() 	Moves every item in the matrix down until it hits a wall or another item. 	TBD
== Popular problems in School ==
=== Hello, world! ===
The Hello, world! program is a trivial program which outputs a static string of text, usually "Hello, world!". In School this can be achieved in just a single line. This program requires interpreter v1.0.1
 print("Hello, world!");
Category:2021
Category:Matrix-based
Category:Languages
Schrodilang

Schrödilang is a little-known esoteric programming language developed by Erwin Schrödinger's illegitimate son Billy Schrödinger. Not much is known about the language, with the exception that the only implementation ever to be written is on a floppy diskette sealed in a water-tight lead box at the bottom of the Atlantic ocean, along with a nuclear radiator and a radiation detector attached to a powerful electromagnet.
Category:Joke languages
Category:Implemented
Category:Unimplemented
Category:Unknown computational class
Category:Usability unknown
Category:2008
Category:Languages
Schrodinger's fish

this is combination of deadfish and alivefish
== commands ==
 s, square
 S, square root, also works for negative numbers
 i, increment
 I, integral the previous values and the thing will be that
 d, decrement
 D, double the thing
 o, output
 O, input
== test programs ==
 Oo #should be cat
 ODo #should be double cat, not two letters of cat, but just get number, and double it and output
 dio #should output 0+1i
Schwa

Schwa or "ə" is language by User:ChuckEsoteric08 inspired by ABCDXYZ.
==Architecture==
Schwa operates solely on a scalar datum known as the input, capable of storing an arbitrary object, and intended to be modified exclusively by an input command that queries the user for a response. Initially empty, the character “ə”, if transmitted into this storage, is apportioned a particular role, which please see below.
==Commands==
Schwa may be at any instant in one of two states, designated as
* 1 (or p)
* 2 (or i)
Additionally, three command tokens exist:
* a
* ə
* e
The command associated with a token depends upon the currently assumed state, producing six different effects as a result of the possible combinations:
Command	State 1 	State 2
a 	Change to state 2 	Get user input and store in the input variable
ə 	Output the content of the input variable	Change to state 1
e 	Start loop that ends if input is “ə” 	Ends loop
==Compiling to FakeScript==
Command	In State 1 	In State 2
a 	NOP 	input
ə 	print #input 	NOP
e 	!label x if #input ə endx	if #input ə endx goto x !label endx
x and endx need to be different for each loop.
==Examples==
===Cat===
 eəaaəəae
===Quine (programming language)(Text) interpreter===
 aaəə
===Somthing like Truth-machine===
 aaəəeəəe
It is like Truth-Machine, but it uses "ə" instead of 0
==See Also==
*Voiced dental fricative - similar language
==Interpreter==
* Common Lisp implementation of the Schwa programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Languages Category:Finite state automata Category:Implemented
Scoop

Scoop is an interpreted, imperative programming language created by User:DisableGraphics that uses an 8-bit integer as its only variable. (Called a for the sake of simplicity).
It features conditional branches (although very limited) and simple loops (while-style).
== Programming in scoop ==
The official documentation includes a programming guide.
== Examples ==
set a print
random 1 120
if >= 65
 print
 if <= 100
 set h print
endif
== External resources ==
* Scoop's webpage
Category:Languages Category:Finite state automata Category:Implemented
Scope

Scope is a limitation placed on where a variable can be used, so that what value a name refers to is never ambiguous. If a programmer defines the variable value-to-be-returned inside a function, then writes an almost identical function for a similar purpose, scope allows her to call the corresponding variable in the second function value-to-be-returned as well. Restrictions on scope mean that variables from within one function can never inadvertently leak values to another function, no matter the names used. There is no consensus on the perfect way to manage scope, although certain systems are common in programming languages.
Philosophically, scope is interrelated with modularity and separation of concerns. That is, it is easiest to reason about programs that can be broken down into discrete parts, and careful scope rules can minimise unwanted interaction between those separate parts.
==Global scope==
The simplest scoping rule is global scope, which means that a variable can be read and written to by any part of the program, or in more extreme cases, the whole computer system. If the programmer sets foo equal to three, then the whole program will see that it is three. Many languages provide facilities to refer global variables in addition to other scoping rules. In general, misuse of global variables is thought to make bugs harder to find, because it is easy to forget to overwrite a saved value from elsewhere in a program. Ideally, (some would say) changing one part of a program should only affect that part of the program.
==Local scope==
A prevalent scoping rule is that variables that are defined within a function should only be available within that particular function. This is especially essential in functional programming in order to avoid side-effects from having one function affect another.
==Dynamic scope vs. Lexical scope==
Languages with scoping rules often divide into two camps: lexical scope, or dynamic scope. While it is generally agreed that local variables should stay inside their respective functions, it can be unclear what is and isn't inside a function. For instance, should a function called from inside another function be able to use variables from the caller? Lexically scoped languages have it that a local variable should be usable from explicit references to it from within the function itself's source code, and nowhere else. Dynamic scope tends to prefer a different system: if a variable is not found within a function, check in its caller, and if not found, in the caller's caller, and so on until the global scope is reached.
Category:Concepts
Scott numeral

A Scott numeral is a natural number encoded into lambda calculus using Mogensen–Scott encoding. In contrast to the better-known Church numerals, Scott numerals have a different performance profile and can be a better choice for certain applications.
== Definition ==
Scott numerals have the following wikipedia:System F type signature:
 ΛX. (ΛR. (X → R) → (R → R)) → (X → X)
Intuitively, Scott encoding provides one input argument per constructor of the equivalent data type. This signature is the encoding of the recursive type:
 data Nat = Succ Nat | Zero
If the numeral is a zero, then it can return the identity function; otherwise, it can pass another Scott numeral to the successor function. The caller chooses the type X where the zeros and other concrete natural numbers are interpreted; the numeral chooses the type R where the successor operation is performed, including the common choice R = X for purely numeric behavior.
== Examples ==
numbers
0 = λs.λz.z
1 = λs.λz.s 0 = λs.λz.s (λs.λz.z)
2 = λs.λz.s 1 = λs.λz.s (λs.λz.s (λs.λz.z))
successor function and predecessor function
succ = λn.λs.λz.s n
pred = λn.n (λx.x) 0
=== Arithmetic ===
First,we need a fixed point combinator
fix = (λx.x x)(λf.λx.x(f f x))
additive function
add = fix (λf.λx.λy.y (λn.succ (f x n)) x)
subtraction function
sub = fix (λf.λx.λy.y (λn.pred (f x n)) x)
multiplication function
mul = fix (λf.λx.λy.y (λn.add x (f x n)) 0)
division function
div = fix (λf.λx.λy.(succ (sub x y)) (λn.succ (f (sub x y) y)) 0)
=== Predicate ===
First,we need boolean.
true = λt.λf.t
false = λt.λf.f
test if a number is zero
isZero = λn.n (λx.false) true
test if a number is less than or equal to another number
leq = λx.λy.isZero (sub x y)
 
test if a number is equal to another number
eq = λx.λy.(leq x y) (leq y x) false
test if a number is less than another number
lt = λx.λy.(eq x y) false (leq x y)
test if a number is even
even = λn.isZero (sub n (mul 2 (div n 2)))
=== Convert between Church numeral ===
First,we need church succ and church pred.
cSucc = λn.λs.λz.s(n s z)
cPred = λn.(n (λp.λx.x (p false) (succ (p false))) (λx.x 0 0)) true
convert to church numeral
toChurch = fix (λf.λx.x (λn.cSucc (f n)) (λs.λz.z))
convert from church numeral
fromChurch = λn.n succ 0
Category: Concepts
Scotty

== History ==
Scotty is an educational esoteric language created in the Spring of 2016 for a course on programming languages. It is an imperative language with a syntax that is incredibly easy to tokenize, making it relatively easy to implement language features without needing to perform any lexical analysis of the input. 
== Description ==
Programs in this language can be split into lines. The final line of the program is a prefix expression, where the result of the evaluation of that expression is the output of the program. The language definition includes variables and functions, which are defined on the first n - 1 lines of the program. Each function can take exactly one parameter, and that parameter is passed by value. Functions cannot access variables outside of the local scope of the function.
Each line of the program can be split on spaces, and each command is uniquely identified by the first token of the expression.
== Grammar ==
<program> ::= <program_lines>
<program_lines> ::= <prefix_exp> | <fn_def> <program_lines> | <var_assign> <program_lines>
<var_assign> ::= <identifier> = <prefix_exp>
<fn_def> ::= fun <identifier> <identifier> = <prefix_exp>
<prefix_exp> ::= + <prefix_exp> <prefix_exp> |
 - <prefix_exp> <prefix_exp> |
 * <prefix_exp> <prefix_exp> |
 / <prefix_exp> <prefix_exp> |
 ( <identifier> <prefix_exp> ) |
 <identifier> |
 <number>
<identifier> ::= <letter><id_tail> | <letter>
<id_tail> ::= <letter><id_tail> | <digit><id_tail> | <letter> | <digit>
<number> ::= -<digits> | <digits>
<digits> ::= <digit><digits> | .<digits> | <digit>
<digit> ::= (0 .. 9)
<letter> ::= ('A'..'Z') ++ ('a'..'z')
== Example Programs ==
=== Simple Numeric Evaluation ===
+ 1 1
=== With Variable Assignment ===
x = + 1 1
+ x 1
=== With Function Definition ===
fun square x = * x x
( square 3 )
=== Functions within Functions ===
fun square x = * x x
fun cube x = * ( square x ) x
( cube 3 )
=== Functions and Variables ===
fun square x = * x x
fun cube x = * ( square x ) x
something = 3
( cube something )
== Interpreter ==
Scotty interpreter written in Haskell
The above interpreter does absolutely NO checking of the input program. It assumes that the code provided is a valid Scotty program. Obvious future work is to add syntax checking to the program.
Category: Languages Category: Educational Category: 2016 Category: Implemented
Scrambled

Scrambled just Satarcrimp with a TREE(3)-like script.
== Syntax ==
No description here.
== Example ==
=== Hello, world! ===
啱䪊㴪种聳膫彼틈䢧莧씲宐녿慯挐裴䢛뎿뺱䯔㺚㷕㻐帟
䢺䂌썊氽㠑樺렶痲峭佥쓑简蠃䙹㼤냽楾넿얲次㜺啯獔틯
櫡㾋耸欐炜舓㥮봌汳蘜粒챪塋죱卐稄栀㐀
(Why does here makes a swastika?)
=== A+B Problem ===
뜥㒉藚엸什㘃孲콸篔燃榱댰밞毒㢪쯏䲐첻긻정懥丅뼌帧
쐰䚣彇㥒舺둏䗝룰셜읔쇄졡䄯瀘䛷뫒젊䍫暑媟磷뤊흮䊇
瘺퇴绀垌촭䗓溵곋넂풋揀㳖茇䠕礞暆愀㻳㱬㵀瑘薒㫅蕘
뢯蝝灭愩畓㘕각䝸쮍듡扂皧휊欽埣洘暾퍗셣螞릹穝幼嫵
뺹썔呙噙끄簋蒤㙻汜䩝뷮䨡堼킀㲻㚻蟦䠙롟廇废삖呆绋
夽漬췙磄篝綟萌杠蘈씿蚶䮶挹嶺묭婗獡嚂䔍疬햂羅쉃䠉
婇벶偤뫀싽兪퓩㑠
(听不懂思密达)
=== FizzBuzz ===
븦㒈曒랥耴䘽濓伹曪깮篏젅㓥웢蒍瘰㭂㺦盇썭䐗㔷㟱㰛
쀥맀䰋䍘羒懇呕奍橌蒀肒茙紛퍱쁄쟗뀦䏹仓톯翗䐀厣셊
胣射릨㧘枷횚랿䤮䉃嗨瓚䴹륲뉘抒흂痪梬户뻭妡燺뇀影
員绘㛳够挊櫥獠眡偰댪䙋䶱奬綋妳綈䳶밫吼盥杛덞됉폍
囈手㯉匠㮇枲蘰艎䢿䘼뫥羳혤뱂砮媶짗亨쇅旒寵緔숷炞
릲퍭㓁欠嵗뭯䬠꺤㧀殃絃㺷蓩碆덦熪셀竱펅瑅㥥읆땁쏾
瑝硘捀侏㼪샩珠㧞켴꼸끃䖫搾嫽搟땁㧓쏱燬휦㦎攌囁뾄
桭构벖㤬圈仨筂徍궿쓜핟荑쬹㝾烐찿엛䴂䮳爐껗藷㺱쁂
媱맙벛붌櫒쿊꽣㾢虔봋킡欽㮚훳돩깍稒螬럪쬽䕹䯍䂌쿐
랫㯿벬拄슜愶얣䖧뮭䮋큱픒웼矝쩣빣㳠檼톥쿥茇兙䤌綮
큒껻塤䐶寇㭄湘擄擩悋춒첻䅼燻㞳㔹젇渆꺡䨏薛秷㓌늗
캻䨄㶵激뷄䈫콏튒嫘㫍薹勊
=== Textual Chess ===
뺪㒊죬엉結彧凍폍庞뚏촛媤蕤羑䰗捑岑瓐凨壳쏨臹按糢
乾㲍擬薅壖웊뫾췪꼇古쀑偆쪕癙煾㨣䛐蕳糷荂嘫놻눯峸
田폛쬮턴扦솄嚦뼂㻲熻藺휆덢傋㓅蚴퀹휧惌짫伹絝뺏㭃
瘰族呐茌䑹줩匰氎蕅蚴䍧䬹곎蚦䝵모胼䩢쨏팲뒚罠桯择
잖㱥嫡췴䣉핁癖嘟댴솀嫪훟憘䶌㓍牁摲쓌칳걖腈닻㻌횩
耄嵍殍㫌멃犭咩띜㫟犰숁嫥蓶匷爤엩㤬嗸㪵슁胆냥봴湧
杍큚洖羿궯읁턝䮏췋湋虱絖哔닯洜뫗냓䡂皺럂댼㨃灚섰
컭㧰煛폝뷎宰퓽䞉델꾶䙲䜅剙窉㠚荀햐寵뾨勢盧㣊휈槩
欬뚚쨔呎홊먰渙㼉岦呺밓篣좣体맟뫛絛끂蛗碌몳彤灆牵
菝츜퉊䄖婑텗絧㫦빳뉎뗪뉾줾硞낮啄灹䁔傗儏㔦첔穇㰡
奮吆짓껻쁷촟熲퀨徲婸䑒袴쑳쒴烌䠵꾟㔥졮퍈돸湢㠔삊
㽹儺笊椁褜㦷쑅䡒䢻艃緰爐䯢첸蠰楆䯙聥孂깻瓜㹰煿츁
㘃湴퀃뵃䜦墦뙐蛩炦歶枌唡朗枒腛灹敽福䢉汋㘼浽쫬죋
읐枒埀繏緷㦙눐慼녁动춤灯㿎걇묈爮䑹细䀿打쏃깁㳚펑
㢳桏럩䆯㟒犄崦귂䑶排绎儑똖갮퍸䓝뗍붻뻦퉧䊯䂲웨뗼
䑷盧丄㬈䦥㯝륳풟럛幵羒戳쒑퐉볱뀶䱷胦伉仸죗인虔䵯
쏙볜좳崔괋䣬콆둅튯싵吓惂莰슓쿴㒲妾맆궠탉楸븰檌夰
蓛歞䲕롎䒝哥昐삡滣먜뺪㲥棸㓵咾漄絕嘟翏뾀䉍沾蛳㒿
븞䔰봠庎뒻荷䢮烍둨떀㾿䑔尦殠䌢攨눺䇸촣욱㚶痂꾡籱
佦莘葼榝簰뱖㷘쎴㲒㦏㭱瞇䛚僄칏猢幼뗏桡㒊斬䞓칭孻
뙟欣䗎촵뺱滹慰䈵䌕纔倽맘쯢婬背䜳岄쾱혎픝㬆슊홤粟
蕚藾쮰㺵濘浊葻뎀툟胚妱휁石뭩杲빰幀撔궱眿쌫葼㰅牻
컎恈埛솠腝后둘뱤㒉狇㻄䦭뻼㨚掰탟킭叵庇앭偺篍葩㛔
샻繲멸촇䁳戯뫣峕㰆띗툍뙧嗚엩톨瘡澶㤙㟑䧯捙師穔䤝
꽕쏰뫶쳮뎦瞗䟘뢹왦沤芌䈱쪧쾱떞侷澶睌肵蕐큄冼㲰탩
䬃밈疘䡱糐疿蠃曀칀暝㙥痪㮎虉參덹庨砥벱쳿恘폧턱윝
洬彫狳죮몠瞹柦縪갗床嗀虳㩿졥짓巚綾倠쓆䎻婻湉芴䭟
뵴禬㢿䵋꾨㭠땝쭞涋퍪쒙퐌䘍氺縔狭仯涫妡쓛烝㗶셰싽
䵶憗둍癆빺僣턚텵혏殭孑塮䭨厣塑㤎図槭嶧绞礹턡씡칖
甼휎닸뭙蔈聊
== Categories ==
Category:Languages Category:Joke languages Category:Turing complete Category:Turing tarpits Category:CJK Category:Pseudonatural Category:Unimplemented Category:Self-modifying