nyuuzyou/wikis huggingface dataset:
Len(language,encoding)

Len(language,encoding) is not a single programming language, but rather a large family of related programming languages, inspired by Lenguage and Unary.
== Syntax ==
Just as in Lenguage, in a Len(language, encoding) program, the length of the program is the only thing that matters. The contents can be anything the programmer wants it to be.
First, the length of the program in the given encoding is calculated. Then, said length is converted to binary, left-padded by zeroes until the binary data is valid in the given encoding, then the binary data is converted to text according to the given encoding. Finally, said text is evaluated as the given language.
For example, in Len(JavaScript,UTF-8), the program will be given as UTF-8 text, the length of the text is converted to binary, left-padded by zeroes to a multiple of 8. The binary data is interpreted as UTF-8 text, and finally run in a JavaScript interpreter.
Most programs will be too large to be practical (see examples below). This problem is compounded exponentially if, for example, you use Len(Len(Len(Javascript,UTF-8),UTF-8),UTF-8).
== Example Hello World program ==
In Len(JavaScript, ASCII), to write a "Hello, world!" program we would start off with a JavaScript program,
 alert("Hello, world!")
and then convert it to binary using the ASCII (7-bit) encoding.
 1100001110110011001011110010111010001010001011100010011011100011110101110111111101000111011100100011001011101100110110011011110101100010000011101111101111111001011011001100100010000110111000100110111000111101011101111111010001110110101001
Then we would interpret that as a number in binary, (equal to 337667834225159471205607980580223574175903847313498720819759389567950249 in decimal) and then create any program we like with that many characters, such as
 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 ...337667834225159471205607980580223574175903847313498720819759389567950000 characters omitted
== Cat program example ==
An example of a cat program in Len(brainfuck,ASCII) would have 12002760285 (01011001011011010111001011001011101 in binary) bytes (12GB!). Although you can store that on a disk that's large enough, you don't want to waste 12GB of disk space for that, do you?
== See also ==
* OCPL, almost the same but not.
Category:Joke languages
Category:2014
Category: Languages
Len2

''''SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED SCRAPPED
''''Bold text''''
Lengthwise

Lengthwise is an esoteric programming language consisting of only two characters. Made on 6/24/22, Lengthwise was created to be minimalistic in every way, making it's concept incredibly easy, but making the creation of programs with it much more tedious and difficult due to how the simplicity limits functionality. Lengthwise is likely to not being anywhere near Turing Complete
==Language description==
Lengthwise was created with the idea of ultra-simplicity in mind. The concept began at a concept of two characters, based off of an idea created of a language similar to brainfuck, but using only two characters, a separator, and an actual character, however, lengthwise was different from this early concept, lengthwise contains an increment character, and an execute character. Lengthwise only has one value, unlike brainfuck, with 30,000, this one value is incremented, and 7 different actions occur based off of what the value is. To allow decrementation, the value has a maximum, or an "overflow point" where the value resets to zero once it is greater than that value. Lengthwises value maximum is 512, so when it is incremented to 513, it becomes 0.
==Length / Count Commands==
These are actions preformed based off of the integer of the value. If it is not a set command, it defaults to printing the ASCII character of that value.
Command 	Description
Length 0 	End the program.
Length 1 	Go back 5 lines.
Length 2 	Skip forward 5 lines.
Length 3 	Print a fast line break.
Length 4 	Read a character, and set the value to its ASCII value.
Length 5 	Set the Console Window title to the text printed in the Console, then, clear the console.
Any Other	Print the character with the respective ASCII value.
==Example(s)==
===Hi Title===
This program prints "hi" and then transfers the printed string to become the title. This program is bundled with the interpreter.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
Category:Languages
Category:2022
Category:Unknown computational class
Category:Implemented
Category:Unusable for programming
Lenta

v0.11 This a work in progress. Written by User:Milcho.
Programs in Lenta consist in a two-dimensional grid of instructions, like Befunge, and operate on a tape of cells, like brainfuck. There is also an extra variable, the buffer, that can be accessed at all times.
==Instructions==
* Unary operators apply to the buffer.
* Binary operators take the current cell and the buffer as operands, and store result in the buffer.
* Logic operators read 0 and less as false, 1 and greater as true, and return 0 for false, 1 for true.
* Any character that is not a valid instruction is ignored.
Symbol	Operator 	Operator
+ 	PLUS 	Add buffer and current cell and store result in buffer.
- 	MINUS 	Subtract buffer from current cell and store result in buffer.
* 	MULT 	Multiply buffer and current cell and store result in buffer.
_ 	DIV 	Divide current cell by buffer and store integer quotient in buffer.
% 	MOD 	Divide current cell by buffer and store remainder in buffer.
0 	ZERO 	Zero the buffer.
< 	LESS 	Store 1 in buffer if current cell is less than buffer, 0 otherwise.
> 	GREATER 	Store 1 in buffer if current cell is greater than buffer, 0 otherwise.
= 	EQUAL 	Store 1 in buffer if current cell is equal to buffer, 0 otherwise.
& 	AND 	Store 1 in buffer if both current cell and buffer are true, 0 otherwise.
 	OR 	Store 1 in buffer if current cell or buffer is true, 0 if both are false.
! 	NOT 	If buffer is 0 or less, set it to 1; if it is 1 or greater, set it to 0.
Symbol	Instruction	Instruction
$ 	START 	Start program here, moving right.
[ 	LEFT 	Move to previous cell.
] 	RIGHT 	Move to next cell.
{ 	N-LEFT 	Move n cells to the left, where n is the value in the buffer.
} 	N-RIGHT 	Move n cells to the right, where n is the value in the buffer.
/ 	RULD 	Reflect flow: right-up, left-down.
\ 	LURD 	Reflect flow: left-up, right-down.
: 	CEL<BUF 	Overwrite current cell with a copy of the buffer.
; 	BUF<CEL 	Overwrite buffer with a copy of the current cell.
@ 	INDEX 	Overwrite buffer with the location index of the current cell.
~ 	SWAP 	Swap the buffer and current cell values.
' 	OUT 	Output the buffer as a character.
, 	OUT 	Output the buffer as an integer.
. 	IN 	Read an ASCII character or an integer from input, and store it in the buffer.
" 	SET 	Overwrite buffer with the ASCII value of the next character in the program (and skip it?).
? 	SKIP 	If the buffer is 0 or less (false), skip next valid instruction.
# 	HALT 	Halt execution.
==Example programs==
Those programs haven't been tested yet.
===Hello, World!===
 $ "H'"e'"l' '"o'" '"W'"o'"r'"l'"d'"!' #
===Addition===
Read in two ints, add their values and print it, and loop until both ints are 0.
 $ 0? / .:].:[+,0=:]0=[&!?\#
 \ /
===Fibonacci sequence===
Read a number N, and print the first N Fibonacci numbers.
 / \
 $ ]0: ]0!: [[ .: 0?/ ; ? / \ \ ] ; , ",' ] ; [ ~ + ] : [[ 0! - : \
 # 
 \ /
==External links==
* Interpreter in Python
Category:LanguagesCategory:Two-dimensional languagesCategory:Cell-basedCategory:Unknown computational classCategory:ImplementedCategory:2011
Lesser known programming languages

The lesser known programming languages are a set of joke languages described in an article by John Unger Zussman published in InfoWorld, Oct 4, 1982. This makes them some of the oldest known esoteric programming languages. 
==The languages==
* C-
* COCAINE
* DOGO
* FIFTH
* LAIDBACK
* LITHP
* SARTRE
* SIMPLE
* SLOBOL
* VALGOL
==Later additions==
Several variations of the list exists. Further verification of its history would be welcome.
* FASTBOL, FOCUSALL, GERITOL and PINBOL seem to originate from the Pi Mu Epsilon Journal, Volume 8, #9, 1983.
* RENE is quite common.
==External resources==
*UseNet post.
*Page by Darrel Damon including several of the extensions mentioned.
*The thalia.org Humor Archives - Computers, search for Little Known Computer Languages. References the Pi Mu Epsilon Journal.
Category:Joke languages
Let's Rewrite String!

Let's Rewrite String! is an esolang by User:ChuckEsoteric08 inspired by Novice
==Specification==
The language has unbounded string memory, which initial value is set to user input. Anything that isn't a command would declare label with that name. There are Two commands in the language:
 x=y
If string contains x and there exist label x, then x would be replaced with y and IP jumps to label x
 x-y
Works the same but it would also print y if statement is true.
==Computational class==
Let's Rewrit String! is Turing-complete, proven by existence of Cyclic tag system interpreter in it:
$
'0
`0
#
^;-;^
^0-0^
^1-1^
^@-@
^;
@0=@
@1=@
@0
@1
$=$
^0
@='
'
'1=@1
'0=@0
'1
#=0#
^1
@=`
`1=@1
`0=@0
`1
#=1#
@
'='
`=`
^@
@#=@#
$=$^
@#
Initial String would look like this: $^Program@Data#
Category:Languages Category:Turing complete Category:Turing tarpits Category:String-rewriting paradigm
Lete

Lete (pronounced leet) is an esolang by User:BoundedBeans where you cannot delete previously entered code.
It is similar to Uyjhmn n in that it’s main weirdness is the IDE.
==IDE==
The IDE must only allow appending to code. It may allow other operations to the appending string to correct typos before it is added, but once the program has been run, the code is “solidified” and cannot be modified other than appending again.
The IDE uses Lete code to generate a brainfuck program, which is then run.
==Instructions==
Popping from an empty stack gives an empty string. Other than that, anything that would normally cause an error is treated as a no-op.
 P - prepend + to the code
 M - prepend - to the code
 L - prepend < to the code
 R - append > to the code (not prepend, just to make it a bit more annoying)
 I - append , to the code
 O - prepend . to the code
 $ - enclose the entire code in square brackets
 ^ - delete the first character from the code
 v - delete the last character from the code
 : - begin construction of a new string, push the old string onto a stack, delete the current string
 ; - append the top string on the stack to the current string, popping it
 _ - jump ahead the number of characters in the current string
 ! - replace the current string with the top string on the stack, popping it
 @ - discard the top string on the stack
 % - duplicate the top string on the stack
 = - swap the top two strings on the stack
 ? - pop the top two strings, take their lengths, return a substring of the current string with the two numbers, push that substring onto the stack.
==Programs==
===Add 3+5===
 PPP:PPPPPR;:PLMR$:=!;:L:=!;
Equivalent to:
 +++++>+++[-<+>]<
===Print an exclamation point===
 PPPPPPPP:MR:LPPPP:=!;$:=!;:R:PO:=!;:=!;
Equivalent to:
 ++++++++[->++++<]>+.
==Computational class==
Lete can construct any brainfuck program, and given any starting code, there is a code that can be appended to cause any other effect (kind of cheating, but : followed by a ton of @s will allow you to start from scratch). Thus, Lete is Turing-complete.
Category:Stack-based
Category:String-rewriting paradigm
Category:Brainfuck equivalents
Category:Languages
Category:Turing complete
Category:Cell-based
Category:Brainfuck derivatives
Category:Unimplemented
Letlang

NumLang is a joke esolang created by PartehTheEsolangDev which uses numbers from 1-6 to make a simple output.
Syntax goes as follows:
 "1" = Exit Program and Output
 "2" = Add 1 to the character value
 "3" = Subtract 1 from the character value
 "4" = Loop the amount of times shown in the next character, cancels out the effect of 1s. 
 "5" = Print "Hello, world!"
 "6" = Squares the character value (value * value)
You can find the Python 3 interpreter he made if you click on "NumLang" at the beginning, or go to this page
-- EDIT -- Name changed to NumLang for conflits with programming language LetLang by LinkDD
Category:Joke languages Category:Languages Category:Total Category:Implemented Category:Output only Category:Unusable for programming
Letters++

WILL IMPROVE AS TIME GOES ON... hopefully...
Letters++ is an esolang created by User:Saka, that is made of, as the name suggests, letters.
== Mark Scanning ==
All mark scanning is relative to the instruction that initiates the mark scan. 
== Data ==
Data is stored "within" the code. All characters that are not lowercase Latin letters will be interpreted as data. To write a lowercase letter, put "w" before the uppercase letter. Numbers (0,1,2,3,4,...) can be incremented as usual, as well as letters (A,B,C...Z,AA,AB...). If you try to increment a symbol (e.g. """), it will do nothing (Won't give an error, won't stop the program, it will act as if it has done it successfully.).
== Instructions ==
Since every instruction is a Latin lowercase letter, all other chars (Such as UPPERCASE, space and punctuation,) are used as "data".
=== I/O ===
Instruction	Description
p 	Print all current stored data as is.
q 	Print data after next marker as is.
n 	Print numbers of next marker.
i 	Take 1 character from input stream, put after mark, if failed, go to next mark.
d 	Delete char after next mark.
=== Control Flow ===
Instruction	Description
a 	Go to mark.
e 	if data after previous mark is equal to data after next mark carry on, else, go to said next mark.
l 	Move the data after the next mark to after the previous mark, if no data on next mark, go to next mark.
r 	Move the data after the previous mark to after the next mark, if no data on previous mark, go to next mark.
x 	Terminate the program.
=== Mark Scanning Controls ===
Instruction	Description
m 	Marker.
s 	Skip the next marker scanned.
b 	Change direction.
g 	Ignore next turn around instruction.
j 	Ignore next skip instruction.
=== Arithmetic ===
Instruction	Description
u 	Increase the value of the data after mark by 1
c 	Decrease the value of the data after mark by 1, if no char or char is 0, go to next mark.
== Example Programs ==
Hello, World!
 HwEwLwLwO, WwOwRwLwD!p
Cat program
 miamp
TM
 imedpxm0dbmpa
Add 2 Numbers
 imimcbgsubjgamsdbpx
Duplicate number
 imcbujusgjammdb
Category:Languages
Category:2019
Category:Unimplemented
Lever

Lever is an esolang made by User:Yes
== Commands ==
Off lever
 /
[_]
On lever
 \
[_]
Wire (1)
-
Wire (2)
|
Off light
{0}
On light
{1}
Combine
=
== Examples ==
NOT gate
 / {1}
[_]---|
XOR gate
 /
[_]---|
 / =--{0}
[_]---|
XNOR gate
 /
[_]---|
 / =--{1}
[_]---|
Category:Languages Category:Two-dimensional languages
Lezy

lezy is a joke esolang created by User:Cinnamony.
The only command is lezy, which prints out "lezy".
==Examples==
 lezy
This prints out "lezy"
 lezy lezy
This prints out "lezylezy"
 lezy
 lezylezy
 lezy lezy
Whitespace does not matter. This prints out "lezylezylezylezylezy"
 lezy
In fact this is a Quine!
==Implementations==
An implementation in Common Lisp shall be adduced:
 (defun skip-whitespaces ()
 "Skips a sequence of zero or more adjacent whitespaces and returns NIL."
 (declare (special source index))
 (loop while (and (< index (length source)) (member (char source index) '(#\Space #\Tab #\Newline) :test #'char=))
 do (incf index)))
 
 (defun expect-lezy ()
 "Expects the keyword \"lezy\", on confirmation moving the INDEX pointer past it and returning no value; otherwise an error is issued."
 (declare (special source index))
 (let ((next-token (subseq source index (min (+ index 4) (length source)))))
 (declare (type string next-token))
 (if (string= next-token "lezy")
 (incf index 4)
 (error "Expected \"lezy\", but encountered ~s." next-token))
 (values)))
 
 (defun interpret-lezy (source &aux (index 0))
 "Interprets the piece of lezy SOURCE code and returns NIL."
 (declare (special source index) (type string source) (type fixnum index))
 (skip-whitespaces)
 (loop while (< index (length source)) do
 (skip-whitespaces)
 (expect-lezy)
 (format T "lezy")
 (skip-whitespaces)))
An implementation in C# is also here:
using System;
public class Lezy
{
 private static string program = "";
 static void Main(string[] args)
 {
 int ch;
 while ((ch = Console.Read()) != -1)
 {
 program += Convert.ToChar(ch);
 }
 int ip = 0;
 while (ip < program.Length - 3)
 {
 if (program.Substring(ip, 4) == "lezy")
 {
 Console.Write("lezy");
 ip += 3;
 }
 ip++;
 }
 }
}
Category:LanguagesCategory:Joke languagesCategory:Implemented
Lhooq

lhooq is a language created by user:Xifeng for describing systems like the Digicomp II toy computers. Programs take the form of relational tables, the representation of which is implementation-dependent. For the purpose of writing and discussing lhooq code, csv format is most convenient. The name of the language comes from the header that begins all csv-format lhooq programs, establishing the four fields 'l' (Line), 'h' (Head), oo (Other Option), and 'q' (Q value, from flip-flop terminology).
==The Language==
The operation of a lhooq program is more or less that of a one instruction set computer, similar to a TOGA computer but with more restrictions, and a strict separation between code and data. Each line of a lhooq program contains a label, two jump destinations, and a single bit of data. Execution begins with the line labeled "init," and consists of toggling a bit, then jumping to the first jump destination if that bit was 0 before toggling, and jumping to the second jump destination if that bit was 1 before toggling. Each bit in memory can only be associated with two possible destinations, and these cannot be changed by the program.
Registers can be defined by linking bits together in groups, and these registers can perform simple arithmetic, but their use is very limited. Since every bit of memory has to be declared ahead of time, it is clearly not Turing-complete, but it is not even obvious that it rises to the level of a linear bounded automaton: it is fairly simple to create a register that can count up or one that can count down, but it is not so easy to even create a register that can both increment and decrement.
Once the program halts, by jumping to a nonexistent line, all line-labels beginning with "out" are output, along with their associated bit value.
===Example===
The implementation of lhooq being incomplete, this is only a hypothetical example, but it looks alright on paper. The program adds the contents of the 'dec' register to the contents of the 'out' register.
 l,h,oo,q
 init,dec-1,out-1,0
 dec-1,dec-2,init,1
 dec-2,dec-4,init,0
 dec-4,dec-8,init,0
 dec-8,halt,init,1
 out-1,init,out-2,0
 out-2,init,out-4,1
 out-4,init,out-8,1
 out-8,init,out-error,0
 out-error,halt,halt,0
Category:Languages
Li1I

li1I is a domain-specific programming language for integer calculations. It supports recursive functions, conditional execution, and expresses arithmetic in Reverse Polish notation.
It was designed by User:TartanLlama in 2017.
The only valid characters in an li1I program are l, i, 1, I and whitespace. There is no syntax for comments. Comments are not necessary in a language of such clarity.
Here's a function which computes the factorial of its argument:
 li1I
 l1iI
 lI1i I li1l i lil1
 l1i1 li1l i 11 ll11 l1ii lil1
 11 l1ii
 l1il
 i 11 llii I i liil l1ii
 l1ii
 
 lI1i IIII
 liI1 i lIi1 11111111111 l1ii
 I l1ii
 l1Ii
==Language==
===Program===
An li1I program consists of the token li1I followed by any number of functions enclosed in braces. Left brace is spelled l1iI and right brace is spelled l1Ii. Here is an empty program:
 li1I
 l1iI
 
 l1Ii
Beautiful.
===Literals and Identifiers===
Function identifiers are of the form I[iI1l]*.
Variable identifiers are of the form i[iI1l]*.
The only type supported in li1I is an integer. The author cannot remember what kind of integer it is. The value of an integer is given by the length of a string of 1s minus 1. E.g. 1 has the value 0, 11 has the value 1, 1111111111 has the value 9 and so on. 
===Functions===
A function is indicated with the token lI1i, which is followed by a function identifier, any number of variable identifiers (parameters), then a brace-enclosed block.
In that brace enclosed block, any number of statements are allowed.
===Statements===
A statement is an expression followed by the token l1ii.
===Expression===
An expression can be:
* The name of a variable, which evaluates to its value.
* A variable declaration, spelled liI1 <variable identifier> lIi1 <expression>, which evaluates to the value of the initialiser.
* A function call, spelled <function identifier> li1l <expression>* lil1, which evaluates to the result of the function call.
* An arithmetic or logical expression (see below).
* A conditional expression (see below).
Arithmetic and logical expressions in li1I are written in Reverse Polish notation.
The following arithmetic operations and their spelling in `li1I` are:
* Addition: llli
* Subtraction: llii
* Multiplication: liil
* Integer division: llil
* Exponentiation: liii
The following logical operations and their spelling in `li1I` are:
* Greater than: ll1i
* Less than: ll1I
* Equality: ll11
* Inequality: l111
A conditional expression is of the form:
 l1i1 li1l <arithmetic or logical expression> lil1
 l1iI
 <then statements>*
 l1Ii 
 l1il l1iI
 <else statements>*
 l1Ii
Is a then with no else supported? Who knows.
==Implementation==
An implementation which targets LLVM can be found on GitHub.
Category: 2017 Category: Joke languages Category: Languages Category: Implemented