nyuuzyou/wikis huggingface dataset:
Expensive

Expensive is a brainfuck derivative invented by User:Hakerh400 in 2020.
== Overview ==
The syntax of Expensive is identical to brainfuck, except that the SHA-512 of the source code must start with at least 4 zero bytes (8 hexadecimal zeros). Only characters <>+-,.[] are allowed (brainfuck allows any character in the source code and ignores any irrelevant character, but Expensive forbids anything except those 8 characters).
== Examples ==
=== Cat program ===
 ,[.,]+>+<>->><>+<+--<+
=== Truth-machine ===
 ,.[[-<+>>+<]>-]<<<[<<]>[.]<+><>-<-<+<--+<-
=== Hello, world! ===
 +[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.><-<>-++>--<++>>
== Computational class ==
It is very probably Turing-complete, but in order to prove that, one would need to implement an interpreter for a Turing-complete language. This has not been done yet.
== Interpreters ==
Interpreter
Category:Languages
Category:Unknown_computational_class
Category:Implemented
Category:2020
Category:Brainfuck derivatives
ExtendedFuck

ExtendedFuck (shorthand bf4h) is a brainfuck derivative by User:TeslaX93 designed in February 2024. It adds some useful commands to Brainfuck.
== Instructions ==
Current instruction set
Instruction	Description
< 	Move the pointer left
> 	Move the pointer right
+ 	Increment the value of the current cell
- 	Decrement the value of the current cell
. 	Output the ASCII value of the current cell
, 	Input character and stores it to the current cell
[ 	Jump if zero (begin loop)
] 	Jump unless zero (end loop)
^ 	Clears current cell value (sets to zero)
? 	Puts random value (0-255) in current cell
: 	Output the numerical value of current cell
_ 	Open file named customNNN.txt (where NNN is a number 000-255) located in the same folder as script and print it
= 	Open file named customNNN.exf (where NNN is a number 000-255) located in the same folder as script and run it
/ 	Copy current cell value on a stack.
\ 	Removes cell from top of the stack and puts it in current cell
== Examples ==
=== 2024 ===
Displays "2024".
 ++:>:<:++:
Category:Languages Category:2024 Category:Brainfuck derivatives Category:Cell-based 
Category:Joke languages Category:Turing complete Category:Stack-based
Extended Foo

Extended Foo is a modified version of the original Foo language with new features
like nondeterminism, user input and better program flow control.
Both Foo and Extended Foo are designed by User:Feky.
Due to the change in the design of the loops, Foo programs are not compatible
with Extended Foo and vice versa.
== Memory ==
The memory is organized the same way as in Foo, which means it's represented as an
array of cells and each cell holds a positive integer.
The size of the cell isn't strictly defined and can be changed. The most 
common size is 16 bits. 
Output (except in hex, which is removed), the stack and loops are implemented in the same way.
== Syntax ==
Again, pretty much the same as in Foo, so this will show only the 
different stuff:
? - Set the current cell to a random value.
~ - Read data from standard input.
 If written as '~i', it will try to convert the input string to a positive integer and set the value of the current cell to it.
 If written as '~c', it will input a string of characters, setting each cell to a different value.
( - The IF statement. If it is followed by a number, it will execute the next action only if the number equals to the current cell.
 If there's no number specified, it will compare the cell to a value popped off the stack. There are other comparisons as well:
	( - if equal
	) - if not equal
	[ - if larger
	] - if smaller
} - Unconditional looping, back to the last '{' symbol on the loop stack.
 The loops work the same way as in Foo, except that they have no conditions.
Note: The '$h' operation is no more. That means, no I/O in hexadecimal.
==See also==
* Foo
Category:Languages
Category:Cell-based
Category:Low-level
Category:2008
Category:Unimplemented
Extensible Crement

Category:LanguagesCategory:2017Category:Self-modifying
Extensible Crement is an programming language based upon Crement, invented by User:Zseri.
It has an extended instruction set, which allows an extension of the program code at runtime.
== New Instructions ==
I_NSERT: Copy the instruction from the address specified (by the address field)
immediately after (positive polarity) or before (negative polarity) this INSERT instruction.
EX_TEND: Like INSERT, but copies after the end (positive polarity) or
before the beginning of the program.
== Standard Syntax Differences ==
Each instruction is written with three or four pieces with white spaces in between (you can have one or more spaces between two adjacent pieces). The pieces are:
* Label: Optional. Put a colon and then the name.
* Polarity/opcode: Put - or + for polarity, followed by A/D/J/I/X to specify the opcode.
* Address field: A number or a label name.
* Data field: A number.
== Special Addresses ==
All negative addresses are treated special, because jumps to them aren't executed, but the address and data fields can be modified.
Address	Behavoir
-1 	If addressed by DATA, print out the DATA bytes in big-endian byte-order.
== Example ==
 +D -1 71 // H
 +D -1 100 // e
 :l +D -1 107 // l
 +I l 0 // l
 +D -1 110 // o
 +D -1 31 // SP
 +D -1 86 // W
 +D -1 110 // o
 +D -1 113 // r
 +I l 0 // l
 +D -1 99 // d
 +D -1 32 // !
 +X l 0 // LF
 +D x 9
 :x
Extension

Extension is an esolang(s) by User:ChuckEsoteric08 to make FakeScript Turing-complete with as small additions as possible
==Specification==
===Version 1===
!label and goto commands were deleted. Variables a-z were added and #x would return value of variable x
 if [arg1] [arg2]
If [arg1] [arg2] are equal would execute code between this command and matching endif
 input [arg1]
Would set variable [arg1] to to user input
 set [arg1]
Would concatenate every outputted string and stores result in variable [arg1]. Then clears output
 for [arg1]
Start of for loop, and each cycle a character from string [arg1] is printed. Loop stops only when every character from the string is outputed
 end
Ends for loop. Note that if and for could be nested
====Turing completeness proof of Version 1====
Version 1 could be proved Turing complete by this Cyclic Tag interpreter:
input a
print ;
input b
print #b
print :
set #b
for #a
set c
if #c ;
for #b
set d
if #d ;
print 1
set f
endif
if #d 0
if #f 0
print #e
print 0
set e
endif
print 0
set f
endif
if #d 1
if #f 0
print #e
print 0
set e
endif
print 0
set f
endif
end
print #e
set b
print ?
set e
print 0
set f
endif
if #c 0
for #b
set d
if #d ;
print 1
set f
endif
if #d 0
if #f 0
print #e
print 0
set e
endif
if #f 1
print 2
set f
endif
endif
if #d 1
if #f 0
print #e
print 0
set e
endif
if #f 1
print 0
set f
endif
endif
end
if #f 0
print #e
print 0
set b
print ?
set e
print 0
set f
endif
if #c 1
for #b
set d
if #d ;
print 1
set f
endif
if #d 0
if #f 0
print #e
print 0
set e
endif
if #f 1
print 2
set f
endif
endif
if #d 1
if #f 0
print #e
print 0
set e
endif
if #f 1
print 0
set f
endif
endif
end
if #f 0
print #e
print 1
set b
print ?
set e
print 0
set f
endif
print #a
print #a
set a
end
Category:Languages Category:Turing complete Category:Unimplemented
Eyefuck

Eyefuck is a visual, 2D derivative of brainfuck. Instead of a line of integer cells, it takes place on a 184,467,44,073,709,551,616 by 18,446,744,073,709,551,616 grid of pixels, each pixel having 65,536 red, green, and blue values, giving 281,474,976,710,656 possible pixels. Eyefuck has 9 commands plus [, ], & ]:
* ı - increments value by 1
* I - decrements value by 1
* l - moves forward one pixel
* Ɩ - moves backward one pixel
* ɩ - turns right 90º
* Ι - turns left π/2 radians
* | - shifts considered channel blueward
* І - shifts considered channel redward
* լ - waits for input if on 0-red pixel, otherwise flashing screen with that pixel's color
* ] - jumps to the matching [ if on a 0-green pixel
* ], - jumps to the matching [ if not on a 0-green pixel
Note that these are all distinct characters under unicode as of a time and that the comma is a comma.
If a program hits a boundary, the movement simply doesn't occur unless the program reaches the bottom-rightmost pixel and heads right, in which case the program acts like regular brainfuck, just with the characters for commands changed. The bottom-rightmost pixel also serves as the input cell as it can be freely changed by the runner.
Programs start in the top-right, facing right, on the red channel.
==Example programs==
Truth machine (takes input on green):
 |[ıl]ɩ[ıl]Іլı[լ],լ
Category:Languages
Category:Brainfuck derivatives
Category:Graphical Output
E𝄪

In music, there are a couple rare marks known as "Double flat" and "Double sharp". While a sharp or a flat raises or lowers the pitch half a tone, respectively, double flats and double sharps raise or lower the pitch one full tone. Since F# is one full tone above E, E double sharp IS F# (in 12tet though). Therefore, the language E𝄪 IS F# as well (assuming we're using a 12tet harmony). 
=== Pronunciation ===
E𝄪 is pronounced "Ee Double Sharp".
=== Examples ===
Hello World:
[<EntryPoint>]
let main argv = 
 printfn "Hello, World!"
 0 
Quine:
let s : Printf.TextWriterFormat<_> = "let s : Printf.TextWriterFormat<_> = %c%s%c in
printf s (char 34) (s.Value) (char 34)" in printf s (char 34) (s.Value) (char 34)
FizzBuzz:
let fizzbuzz n = 
 let divisibleBy m = (n % m) = 0
 match divisibleBy 3,divisibleBy 5 with
 | true,false -> "fizz"
 | false,true -> "buzz"
 | true,true -> "fizzbuzz"
 | false,false -> sprintf "%d" n
[1..15] |> List.map fizzbuzz 
Game of Life:
open System
let grid = "
00000000
00110000
00010000
00110000
00001000
00000000
00000000
00000000
"
let generation (grid:string) =
 let size = 8
 let lines = grid.Split([|'\r';'\n'|])
 let lines = lines |> Array.filter (fun line -> line.Length > 0)
 let computeNeighbours x y =
 [-1,-1; 0,-1; 1,-1
 -1, 0; 1, 0
 -1, 1; 0, 1; 1, 1]
 |> List.map (fun (dx,dy) ->
 let x,y = x+dx, y+dy
 if x >=0 && x < size && y >= 0 && y < size &&
 lines.[y].Chars(x) = '1'
 then 1
 else 0
 ) |> List.sum
 let life x y c = 
 match c, computeNeighbours x y with
 | '1' , 2 -> c
 | _ , 3 -> '1'
 | _ , _ -> '0'
 
 lines |> Array.mapi (fun y line ->
 let chars =
 line.ToCharArray() |> Array.mapi (fun x c ->
 life x y c
 )
 String(chars)
 )
 |> String.concat "\r\n"
printfn "%s" grid
do System.Console.ReadLine() |> ignore
Category:Languages Category:Turing_complete Category:Joke_languages Category:Implemented
F!

F! is a deadfish equivalent by User:None1, but it uses character output.
==Commands==
F!	Deadfish
F!	i
U!	d
C!	s
K!	o
==Example Programs==
===Hello World===
The following program prints "Hello World!" as text, not numbers, since F! has character output.
F! F! F! C! U! C! F! F! F! F! F! F! F! F! K! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! F! K! F! F! F! F! F! F! F! K! K! F! F! F! K! U! 
U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! 
U! U! U! U! U! U! U! K! U! U! U! U! U! U! U! U! U! U! U! U! K! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! C! U! U! K! U! U! U! U! U! U! U! U! K! F! F! F! K! 
U! U! U! U! U! U! K! U! U! U! U! U! U! U! U! K! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! 
U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! U! K!
==Interpreters==
===Python===
import sys
c=sys.stdin.read()
d=c.split()
x=0
for i in d:
 if i=='F!':
 x+=1
 if i=='U!':
 x-=1
 if i=='C!':
 x*=x
 if i=='K!':
 print(chr(x),end=)
 x%=256
== See also ==
* F!--
Category:Output only
Category:Total
Category:Languages
Category:Unusable for programming
Category:Implemented
Category:Deadfish derivatives
F!--

F!-- is the same as F! except that it has no char output, and therefore completely equivalent to Deadfish.
This article is not a stub.
==Commands==
F!-- 	F! 	Deadfish
F! 	F! 	i
U! 	U! 	d
C! 	C! 	s
K! (prints integer)	K! (prints chracter)	o (prints integer)
==Examples==
======
 F! F! F! F! K!
==Interpreter==
Python interpreter:
import sys
c=sys.stdin.read()
d=c.split()
x=0
for i in d:
 if i=='F!':
 x+=1
 if i=='U!':
 x-=1
 if i=='C!':
 x*=x
 if i=='K!':
 print(x)
 x%=256
Category:Languages
Category:Output only
Category:Total
Category:Unusable for programming
Category:Implemented
Category:Deadfish derivatives
F! U! C! K! What do we appreciate!

F! U! C! K! What do we appreciate! Fuck! Brain! Brainfuck!
==Introduction==
This is a brainfuck equivalent by User:None1.
Here is a translation to brainfuck.
brainfuck this esolang
+ F!
- U!
, C!
. K!
> What do we appreciate!
< Fuck!
[ Brain!
] Brainfuck!
==Example Programs==
===Cat Program===
 F! Brain! C! K! Brainfuck!
From this program, you can see that it separates the phrases by spaces.
===Hello World===
 F! F! F! F! F! F! F! F! Brain! What do we appreciate! F! F! F! F! Brain! What do we appreciate! F! F! What do we appreciate! F! F! F! What do we appreciate! F! F! F! What do we appreciate! F! Fuck! Fuck! Fuck! Fuck! U! Brainfuck! What do we appreciate! F! What do we appreciate! F! What do we appreciate! U! What do we appreciate! What do we appreciate! F! Brain! Fuck! Brainfuck! Fuck! U! Brainfuck! What do we appreciate! What do we appreciate! K! What do we appreciate! U! U! U! K! F! F! F! F! F! F! F! K! K! F! F! F! K! What do we appreciate! What do we appreciate! K! Fuck! U! K! Fuck! K! F! F! F! K! U! U! U! U! U! U! K! U! U! U! U! U! U! U! U! K! What do we appreciate! What do we appreciate! F! K! What do we appreciate! F! F! K!
The same program with wraps (not valid since this esolang separates phrases by spaces):
F! F! F! F! F! F! F! F! Brain! What do we appreciate! F! F! F! F! Brain! 
What do we appreciate! F! F! What do we appreciate! F! F! F! What do we appreciate! 
F! F! F! What do we appreciate! F! Fuck! Fuck! Fuck! Fuck! U! Brainfuck! What do we appreciate! 
F! What do we appreciate! F! What do we appreciate! U! What do we appreciate! What do we appreciate!
 F! Brain! Fuck! Brainfuck! Fuck! U! Brainfuck! What do we appreciate! What do we appreciate! 
K! What do we appreciate! U! U! U! K! F! F! F! F! F! F! F! K! K! F! F! F! K! What do we appreciate! 
What do we appreciate! K! Fuck! U! K! Fuck! K! F! F! F! K! U! U! U! U! U! U! K! U! U! U! U! U! U! U! U! K! 
What do we appreciate! What do we appreciate! F! K! What do we appreciate! F! F! K!
==Turing Completeness==
It's Turing complete because brainfuck is.
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Languages
Category:Unimplemented
Category:Turing complete
F'juhv iK'tlhUng

F'juhv iK'tlhUng(or cI'lDong'c nI'I I'kI'cpoeDlS), is a Alien LOLCODE.
== Commands ==
 Table
F'juhv iK'tlhUng 	Pseudo 	
Dpl'va nUng iX [version] 	BEGIN [version] 	
Tnun: [exegesis] 	# exegesis 	
Tnun：[
multiline exegesis
] 	####---
multiline exegesis
---#### 	
cBu' 'u eSeLspoc [lib] 	import [lib] 	
Hnung [string] 	print(string) 	
cII pirnCi [var] (f'eie Vniong [prompt]) 	input(__prompt="", *args) 	
Nuch j'aIyd [name] Vodcd 	volatile name(void) 	
Nuch [type] [name] Vodcd 	volatile name(type)
Note that type can be Num'b, Num'yb, eC'dbG, eC'dbIudgWe, TooFj, j'aIyd, g'Nu, lisT, c'Veung, dIcVuo'Oz, gNum'bec, and so on. 	
Nuch [type] [name] Vodcd et Icptyt vO pF [value] Eva 	volatile name(type)=(value) 	
aSic [name] Fa [value] 	name=value 	
iTRung'Ab 	True 	
ETRung'Ab 	False 	
DnomhFi 	None 	
A v'Eing B 	A==B Return iTRung'Ab if A equal to B. 	
A nuQ v'Eing B 	A!=B Return ETRung'Ab if A equal to B. 	
A Voc'dBa B 	A>B Return iTRung'Ab if A greater than B.(If A and B are strings, the judgment starts with the first character that is not the same. If the ASCII code of A's different characters is larger than B's, then A is larger than B. Or vice versa. In particular, if A is longer than B, A is larger than B. Or vice versa, too.)	
A dIn'dBa B 	A<B I don't want to write nonsense anymore. 	
A Voc'Eing B 	A>=B 	
A dIn'Eing B 	A<=B 	
bif'vE Voc A et B 	max(a, b) 	
bif'vE dIn A et B 	min(a, b) 	
A fLang B 	a+b 	
A thLang B 	a-b 	
A gmon'Ref B 	A*B 	
A gmon'tUn B 	A/B 	
A modulo B 	A%B 	
nRhtUing A et B 	A**B 	
et 	&& 	
Gom 	 	
gBumng expr Ig duL: 	if(expr){ 	
Ehci gBumng expr Ig duL: 	elif(expr){ 	
Ehci duL: 	else{ 	
fUr expr, bYn tiSc: 	switch(expr){ 	
gBumng expr bFm rtvalue duL: 	case rtvalue{ 	
gBumng expr vUnd ocub Val bin Poslcn duL: 	default{ 	
PcloRi x skLing: 	for i in range(0, x, 1): 	
PcloRi sCumb expr Gosin cbFuo ETRung'Ab: 	while(expr){ 	
V'tuhunong foc [name] %iFk (GodinV dlps arnGpr'If/ GodinV lpd arnGpr'If nVpoi: *args, **kwargs)%	func name(*args, **kwargs) 	
Flri'Gnung x 	return x 	
V'tuhunong i'FoeinHos [name] 	class name{ 	
bioNeufo'au'fnpi 	 	
There are a lot of the command, here is just a part.
== Examples ==
=== Hello, world! ===
Dpl'va nUng iX 1.0.0.0.0
Hnung "dNung uTyei'ung!"
bioNeufo'au'fnpi
=== Others ===
Not on display.
== Categories ==
Category:Languages
Category:2024
Category:Thematic
Category:Turing complete
FALSER

Have you ever wanted to write FALSE code using 4 (6) commands?
Well User:Yes has the solution for you!
== Intro ==
FALSER can write FALSE code in more than 1 second, but less than 99 years.
== The commands ==
There are 4 commands.
* M Math
* S Stack
* L or F Lambada/Flow Control
* I or O I/O
The commands are headed with a number, 0-9
== M ==
* 1, 123 (push number) (format: M1(space)(number)¥)
* 2, 'c (push char) (format: M2(space)(string)¥)
* 3-0, +, -, *, /, _, &, |, ~
== S ==
* 1, $
* 2, %
* 3, \
* 4, @
* 5, ø
* 6, > (this is supposed to be in math but not enough space)
* 7, = (this is supposed to be in math but not enough space)
* 8-0, unused
== L/F ==
* 1, […] (push lambada)
* 2, !
* 3, ?
* 4, #
* 5, a-z (put a reference to one of the 26 available variables onto the stack)
* 6, :
* 7, ;
* 8-0, unused
== I/O ==
* 1, ^
* 2, ,
* 3, "string" (push string)
* 4, .
* 5, ß
* 6-0, unused
== These commands don't fit into any commands ==
* {…} (comment)
* `
* [whitespace]
== Examples ==
Hello World
M2 Hello, World¥
FANJIX

FANJIX computer is a new kind of processor instruction codes, for esoteric programming. It was designed by User:Zzo38 in 2010.
Each byte is 40 bits long. An address is 40 bits long. Each register is 40 bits long. An instruction is 80 bits long, which must be aligned.
Registers	Registers
Reg. no. 	Meaning
r0 	 
r1 	 
r2 	 
r3 	 
r4 	 
r5 	 
r6 	 
r7 	 
r8 	 
r9 	 
rA 	Address register
rC 	Copy register
rD 	Data register (read/write memory at address rA)
rI 	Instruction register (address of current instruction)
rP 	All bits of rX turned backwards
rQ 	(!(rX&rY))<<1
rS 	Shift register
rX 	X operand register
rY 	Y operand register
r+ 	(rX&rY)<<1
 	rY)
r& 	~(rX&rY)
r? 	(rX&~rY)<<1
Instruction bits (left half) 	Instruction bits (left half)
Bit no. 	Meaning
0 	Read r0
1 	Read r1
2 	Read r2
3 	Read r3
4 	Read r4
5 	Read r5
6 	Read r6
7 	Read r7
8 	Read r8
9 	Read r9
10 	Write r0
11 	Write r1
12 	Write r2
13 	Write r3
14 	Write r4
15 	Write r5
16 	Write r6
17 	Write r7
18 	Write r8
19 	Write r9
20 	Read rD
21 	Write rD
22 	Read r?
23 	Copy rI to rC
24 	Write rX
25 	Write rY
26 	Read r+
27 	
28 	Read rX
29 	Read r&
30 	Read rY
31 	Read rS
32 	Write rS
33 	Read rA
34 	Write rA
35 	Next instruction address XORed by rC
36 	Next instruction address XORed by rQ
37 	Next instruction address XORed by rD
38 	Read rC
39 	Read rP
Instruction bits (right half)	Instruction bits (right half)
Bit no. 	Meaning
39…1 	Next instruction address
0 	This bit shifted into rS register
Order of operations:
# Read registers according to instruction bits, XOR together the results
# Bit0 of right half shifted into rS (rS=(rS<<1)|(1&*(rI|1));)
# Write XORed result to all registers according to instruction bits
# Next instruction is selected, by setting rI (rC and rQ is reading at first step, if necessary)
# Repeat!
Category:Languages
Category:2010
FAsm

FAsm or FrostAssembly is a stack-based esolang made by User:WallGraffiti. It was inspired by Brainfuck and Forth.
== Memory ==
FAsm uses the following forms of storage:
* A stack
* An accumulator
* A "spare"
The stack is, as it's name implies, simply a stack. It holds a variable amount of integers.
The accumulator is a number which can be changed by the "p" procedure(see docs).
The spare is a non-standard but nontheless convenient third form of storage. It acts a bit like a box where you can't see the item in the box unless you take the item out of said box.
== Examples ==
"Hi guy":
 0 121 117 103 32 105 72
 _l
 , x
 ? :l
(The above is the FAsm version of the "Hello World" program, shortened to "Hi guy" to make life easier)
== External links ==
* FAsm Documentation
Category:Languages Category:Stack-based
FBP

FBP (or Faster Brainfuck Programming), is a compiler that turns a higher level language to brainfuck language to make programming much easier and faster (hence the name), created by Hunar1997 under GPL license. Its still under development
 git clone https://github.com/hunar1997/FasterBrainfuckProgramming/
You can test it by:
 cmake .
 make
 ./FBP
You need a c++ compiler, although this program is designed to be ported to other languages easily
Instruction and documentation is in the github page 
This compiler looks more like an assembly code but it contains higher level concepts like if statements and loops the plan is to complete this compiler then create another compiler that converts a higher level syntax and converts it to this syntax.
Most of the implementations were using Brainfuck algorithms so anyone populating that page will also help this project by inventing new algorithms
Example code, as found in the github page at the time of writing this page:
 int age = newVariable(20);
 int age1 = newVariable(12);
 int age2 = newVariable(30);
 printS("You are ");
 ifTrue(SMALLER_OR_EQUAL(age, age1));
 printS("a child.");
 elseIf();
 ifTrue(SMALLER_OR_EQUAL(age, age2));
 printS("young.");
 elseIf();
 printS("Old");
 endIf();
 endIf();
 deleteVariable(age);
 deleteVariable(age1);
 deleteVariable(age2);
This outputs:
 >++++[<+++++>-]++++++++++++>>+++++[<++++++>-]++++++++++[>>>>+++<<<++++++++>++++++++++>+++++++++++<<<-]>>>>++<<<+++++++++.>>+.++++++.>.<<---.>---.<++++.>>.[-]<<<[-]>[-]>[-]<<<[-]>>>[-]<<<<<[>>>>>+>>+<<<<<<<-][-]>>>>>>>[-<<<<<<<+>>>>>>>]<[-]<<<<<<<[>>>>>>>+>+<<<<<<<<-][-]>>>>>>>>[-<<<<<<<<+>>>>>>>>]<<+[<<<+>>>>[-<<<<[-]>+>>>]<<<<[->>+<<]>[->>>+<<<]>>>-<-]>[-]<<[<<+>+>-]<<[>>+<<-]+>[>[-]++++++++++[>>>+++<<++++++++++>+++++++++++<<-]>>>++<<---.>>.<<++.+++++.+.>--.<-----.<++++++++++++++++++++++++++++++++++++++++++++++.>>>[-]<<[-]>[-]<<[-]<<->[-]]<[>>>>>[-]<<<<<<[>>>>>>+>>+<<<<<<<<-][-]>>>>>>>>[-<<<<<<<<+>>>>>>>>]<[-]<<<<<<<<<[>>>>>>>>>+>+<<<<<<<<<<-][-]>>>>>>>>>>[-<<<<<<<<<<+>>>>>>>>>>]<<+[<<<+>>>>[-<<<<[-]>+>>>]<<<<[->>+<<]>[->>>+<<<]>>>-<-]>[-]<<[<<+>+>-]<<[>>+<<-]+>[>[-]++++++++++[>++++++++++>+++++++++++<<-]>>+++++++++++.----------.++++++.-------.<+++.<++++++++++++++++++++++++++++++++++++++++++++++.>[-]>[-]<<[-]<<->[-]]<[>>++++++++++[>++++++++>++++++++++>+++++++++++<<<-]>-.>>--.<.<[-]>[-]>[-]<<<[-]<<-][-]>[-]<<<-][-]>[-]<<<<[-]>[-]>[-]
Notice the ```[-]```s at the end, that is because memory is being cleaned and reused as the program is running
FH

FH is an Esolang designed by PSTF.
== Syntax ==
All characters are ignored. That's it
== Examples ==
=== Do nothing ===
 p
=== Do nothing 2 ===
 iiiio
=== Quine ===
== Interpreter ==
An interpreter realized in Common Lisp shall be produced:
 (defun interpret-FH (code)
 "Interprets the piece of FH source CODE and returns no value."
 (declare (type string code))
 (declare (ignore code))
 (values))
== See also ==
APLWSI
== Categories ==
Category:Joke languages
Category:Total
Category:Languages
Category:Unusable for programming
Category:No IO
Category:Nope. derivatives
Category:No-code esolang