nyuuzyou/wikis huggingface dataset:
BubbleLang/Keywords

== Keyword List ==
 Keyword List
CMD 	Meaning
False 	Logical 0.
None 	A nil constant.
True 	Logical 1. P.S.: True+True=2
if 	If-statement.
elif 	Equal el(se )if.
else 	If-else final statement.
var 	Define variable.
const 	Define constant.
import 	Import a library externally.
from 	Import all (or partial) declarations and definitions from the Standard Library.
int, float, and so on	See BubbleLang#Types.
for 	Iterative loops.
while 	Conditional loops.
continue 	Abort this cycle and proceed to the next round.
break 	Jump straight out of the loop.
try 	Attempted execution of code that may cause an error.
except 	Specifies the code to run if the code inside the try statement block does throw an error.
finally 	Regardless of whether the statements in the try block are successfully executed or not, the statements in the finally block will be executed.
in 	Returns True if the element appears in a list/tuple (or a key-value pair appears in a dictionary), otherwise False.
assert 	Similar to an if-else statement block, but if the condition (assertion) is not true, an assertion error is raised.
lambda 	You should know lambda expressions, right?
global 	If there is a variable with the same name as the global variable, the global variable is called instead of the local variable.
function 	Define function.
class 	Define object.
raise 	Throw an error directly.
pass 	Something that can act as a placeholder.
with 	If you don't put the actions you want to perform after opening the file in the with block, it will lead to fatal consequences: you will not be able to close the file in time after the error occurs.
return 	Return a value.
delete 	Delete a variable.
undefine 	Similar to a delete statement, but deleting (dedefining) a function (or an object).
and 	Only when both conditions are true will it return to True.
or 	As long as one condition is true, it returns to True.
not 	If the condition is True, return False.
bwand 	Only if one of the binary bits of both operands is 1, the resulting binary bit is set to 1.
bwor 	As long as one of the binary bits of an operand is 1, the corresponding binary bit of the result is set to 1.
bwnot 	If the operand is x and the result is y, then y = (-x)-1.
bwxor 	If one of the binary bits of the two operands is the same, the corresponding binary bit of the result is set to 0.
shiftl 	Shift to the left, and shift x bits is multiplied by 2 to the xth power.
shiftr 	Shift to the right, and shift x bits is divided by 2 to the xth power(integer division).
BubbleLang/Operators

Main page: BubbleLang
== Monocular operators ==
 Monocular operators
Operator	Meaning
!x 	If x will return True then return False.
~x 	Get (-x)-1.
== Binocular operators ==
 Binocular operators
Operator	Meaning 	
x+y 	Returns the sum of x and y. 	
x-y 	Returns the difference between x and y. 	
x*y 	Returns the product of x and y. 	
x/y 	Returns the number of x divided by y. 	
x//y 	Returns the quotient of x divided by y. 	
x%y 	Returns the remainder of x divided by y. 	
x&&y 	If both x and y are True, the result is True.	
x 	y 	If one of x and y is true, the result is true.
x&y 	Returns the result of x bitwise AND y. 	
y 	Returns the result of x bitwise OR y. 	
x^y 	Returns the result of x bitwise XOR y. 	
x**y 	Returns xy. 	
x>y 	If x is greater than y, it returns True. 	
x<y 	If x is less than y, it returns True. 	
x==y 	If x is equal to y, it returns True. 	
x<=y 	If x is greater than y, it returns False. 	
x>=y 	If x is less than y, it returns False. 	
x!=y 	If x is equal to y, it returns False. 	
== Trinocular operator ==
 Trinocular operator
Operator 	Meaning
z?x:y 	If z is True then return x, otherwise return y.
x if z else y	If z is True then return x, otherwise return y. To be precise, this is not strictly an "operator", because it actually has two keywords. (I'll just say I got inspiration from Python, you don't fucking believe it yet)
Bucket

Bucket is a set of languages involving 3 basic operations invented by User:A. The language variant is described by the tuple (a,b), where a<=b.
What you can do is:
* Empty the bucket a or b
* Fill the bucket a or b
* Pour units of liquid from a to b or vice versa, until the former is empty or the latter is full (whichever one happens first)
"a" or "b" means the maximum amount of that bucket is a or b.
== Commands ==
Where a is less than or equal to b in the tuple (a,b):
f: fills a
F: fills b
e: empties a
E: empties b
p: pours from a to b
P: pours from b to a
== Examples in (3,4) ==
All values are stored in the "4" bucket.
=== 0 ===
No code is necessary. It was set to 0.
=== 1 ===
 FP
=== 2 ===
 FPePFP
=== 3 ===
 fp
=== 4 ===
 F
=== Increment bucket 4 ===
 PFP
=== Decrement bucket 4 ===
 fpEp
== Hello World! program in Bucket for debugging in integers (derivative (1,119)) ==
fpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfp
fpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpOfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpOfpfpfpfpfpfpfpOOfpfp
fpOPePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePeP
ePePePePePePePePePePePePeOPePePePePePePePePePePePeOfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpf
pfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpf
pOPePePePePePePePeOfpfpfpOPePePePePePeOPePePePePePePePeOPePePePePePePePePePePePePePePePePePePePePePePePePePePePe
PePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePePeO
== Implementation in C (provided output instructions just for debugging)==
#include <stdio.h>
int main(int argc, char *argv[]) {
	FILE *fp=fopen(argv[1],"r");
	char *code,c;
	for(int i=0;(c=fgetc(fp))!=EOF;i++)
		code[i]=c;
	int a,b;
	printf("Enter the tuple (a,b): ");
	scanf("%d %d",&a,&b);
	int x=0, y=0;
	for(int i=0;code[i]!='\0';i++) {
		while(x>a) {
			x--;
			y++;
		}
		while(y>b) {
			y--;
			x++;
		}
		while(x<0) {
			x++;
			y--;
		}
		while(y<0) {
			y++;
			x--;
		}
		if(code[i]=='f')
			x=a;
		else if(code[i]=='F')
			y=b;
		else if(code[i]=='e')
			x=0;
		else if(code[i]=='E')
			y=0;
		else if(code[i]=='p')
			while(x>0||y0) {
				y--;
				x++;
			}
		else if(code[i]=='o')
			printf("%d\n",x);
		else if(code[i]=='O')
			printf("%d\n",y);
	}
	return 0;
}
Here is an implementation competition.
Category:Languages
Category:2019
Category:Implemented
Category:Low-level
Category:No IO
Category:Finite state automata
BugSophia

bugSophia (bS for short) is a massively concurrent programming language. The language represents data as bytes being carried by bugs through a 2D field of paths. Each bug can carry only one byte. When a bug reaches an intersection it creates concurrently running copies of itself that travel down each possible path. Unary operations occur when bugs travel over commands. Binary (and higher-ary) operations occur when multiple bugs travel over commands at the same time.
The language uses FIFO "streams" to store and communicate large numbers of bytes. A stream is represented by a Unicode character. The ' . and , commands (write, wait-until-read, and read, respectively) operate on streams adjacent to them. The stan rune (ᛥ) in particular represents standard io.
==Example programs==
(Note: Parts of these examples are in Unicode, so they may vomit out little blocks (or question marks) if you don't have the right font.)
===Hello, World!===
 "+-+-+-+-+-+-+-+-+-+-+-+-+
 ` ` ` ` ` ` ` ` ` ` ` ` `
 H e l l o , W o r l d !
 ᛥ'<-<-<-<-<-<-<-<-<-<-<-<-<
===Cat===
 "v-<
 .ᛥ'
 >-^
===Truncated 99 bottles===
 ">v 
 |<
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` |
 b o t t l e s o f b e e r o n t h e w a l l . |
 ᜀ'<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<-<
 >-v
 | | <---counter
 ᜁ' (
 ^-<-c`-" 
 >-v
 ᜀ. ?
 ^-+
 | |
 @ #ᛥ'
 " ᜁ | | 
 >--.---~g------------------------|
 | ~ main loop | 
 | +v-" | 
 | ^< |
 ^--------------------------------<
Category:Languages
Category:Concurrent programming
Category:2007
Category:Two-dimensional languages
Category:Unimplemented
Built-out

Built-out is a stack-based work-in-progress esoteric programming language created by User:Bo Tie that appears to have built-ins, but doesn't.
== Commands ==
Before running: push each character of input to stack 2
Command	Function
a 	go to start of script if stack 2 is not empty
c 	drop item of stack 2 and push it to stack 1
h 	duplicate top of stack 1
r 	convert character (1-9) at top of stack 1 to integer if possible
t 	if not last 't' in script, swap stacks 1 and 2; otherwise do nothing but EOF can return here unless 'u' disables it
u 	toggle eof loop if top item of stack 1 is falsy
EOF 	pop item of stack 1 if stack 1 is not empty, then go to previous 't' if stack 1 is still not empty, terminate if previous 't' does not exist or stack 1 is empty
== Examples ==
Cat program:
 cat
Truth machine:
 truth
== Interpreter ==
Repl.it
Category:Languages Category:Implemented
Bukkake

Bukkake is an esoteric programming language extending brainfuck with primitives for multithreading. It adds three characters for spawning, blocking, and declaring another procedure. The comparability of procedures to C or Java procedures is limited because in order to "call" such a procedure, one must spawn another thread.
== Structure ==
A file is a series of lines, and each line is a procedure; thus the newline character has meaning in Bukkake, both as a separator and as an exit. The asterisk character spawns a thread relative to the current line according to the current byte. The vertical bar waits until all threads with a vertical bar in their line have reached the bar.
== Examples ==
A forkbomb can be written in two characters:
 **
The initial thread will create two new copies of itself and terminate, but each new copy will also create two copies, consuming the resources of the host machine.
Deadlock can be achieved in three characters:
 |*|
The initial thread will pass the first barrier because it will be the only thread but after spawning another thread it will wait at the second barrier while the new thread waits at the first, causing deadlock.
== Futures ==
A future procedure call could be created by spawning a relative thread and later waiting for that thread to set a byte to zero.
== Backwards Compatibility ==
A bukkake interpreter can run any brainfuck program (so long as it lacks all of the three new characters) without any change in behavior.
== Further reading ==
Bukkake JIT Compiler/Interpreter
category:Brainfuck derivatives Category:Languages Category:Turing complete Category:Cell-based Category:Turing tarpits Category:Low-level Category:Concurrent programming Category:Implemented
Bulgu

Bulgu is a minimalistic language designed around self-modification. It was created by User:revcompgeek on Apr 12, 2010. The main idea is using commands to search through memory (both code and data) to move a pointer around. Jumping involves using this pointer, so making decisions and loops requires moving the pointer between the data being modified and the code to jump to.
== Instructions ==
 : change delimiter to next char and skip it
 ; change delimiter to char at pointer
 [] move pointer to prev/next char
 {} move pointer to prev/next delimiter
 
 * move the pointer to the marker
 ~ swap the pointer with the marker
 
 +- add/subtract 1 to char at pointer
 &_ add/subtract char at marker to char at pointer
 
 % compare char at pointer to char at marker (result saved)
 swap the pointer with the Program Counter if
 > greater
 < less
 = equal
 
 IO
 ., input/output char at pointer
== Information ==
The delimiter starts as " " (a space)
== Examples ==
=== Hello World! ===
 :|}}}]~|*.]~{{%<>{[.}}=
 |Hello World!|
Category:Languages
Category:Self-modifying
Category:2010
BullScript

==BullScript:==
BullScript is a language used for creating libraries for DoFor,
it was made to be realy bad.
please note that DoFor dose not come with any libraries.
===Commands:===
 
 Commands
Command 	what it does
¤NameNumbers#	creates a variable with the name Name but its value is going to be the sum of all the numbers you put in the place of Numbers, this means that variable names cant have numbers in them
==See also==
* DoFor
Category:Languages Category:Total
Bullfrog

Bullfrog is an esoteric programming language, designed by Ryan Kusnery, without conditional jumps. It is a sort of cross between Forth and Assembly. Despite the lack of conditional jumps they can be simulated because the JUMP instruction gets an address from the top of the stack.
Bullfrog was part of the inspiration for SMITH, a language without any jumps whatsoever.
==External resources==
* 
Category:Languages
Category:Implemented
Category:Stack-based
Category:Low-level
Bully automaton

A bully automaton is an ad-hoc extension of a cellular automaton in which certain state transitions, while occurring, can also unilaterally force other, non-adjacent cells to assume certain state transitions.
The name comes from the idea that the one cell "bullies" the other cells around, regardless of those cells' circumstances. This bullying typically leads to very complex interactions; it may or may not, for example, cause a chain reaction of state changes, depending on how the rules are defined.
The first language to employ a bully automaton is probably RUBE. Its successor, RUBE II, uses a more regular and predictable (but still as of yet unformalized) approach. ODDBALL can be described as a meta-language for defining bully automata.
==See also==
* Cellular automaton
* Particle automaton
Category: Computational models
BurainfisHow to learn this langQ9+ with functions

BurainfisHow to learn this langQ9+ is a programming language created in 2023 by User:Cinnamony that merges BF with Deadfish and HQ9+ and Burgercamp and Brainf with functions and How to learn this language and Burgercamp.
Unlike Deadfish, Burgercamp and HQ9+, it is tape based and does not follow deadfish tradition of setting cells value to 0 if value == -1 || value == 256 || value == 25.
BrainfisHQ9+ is backward compatible with brainfuck and hq9+ as well as being able to run some Deadfish programs. This is not the case for BurainfisHow to learn this langQ9+ with functions.
==Commands==
Command	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
+ i I 	Increment the memory cell under the pointer by 7
- d D 	Decrement the memory cell under the pointer by 3
s S 	Squares the memory cell under the pointer
m M 	Multiplies the memory cell under the pointer by 5
. o O 	Output the character signified by the cell at the pointer
o 	Output byte on the right apart from i o and q.
, i 	Input a character and store it in the cell at the pointer
[ 	Jump past the matching ] if the cell under the pointer is 0
] 	Jump back to the matching [ if the cell under the pointer is nonzero
h H 	Output "Hello, World"
9 	Output the lyrics to "99 Bottles of Beer"
q Q 	Output the program source code or quine.
: 	Start function definition, call it with symbol behind.
; 	End function definition.
q 	Repeat the program.
==See also==
* FISHQ9+
* BrainfisHQ9+
Category:Languages
Category:2023
Category:Brainfuck derivatives
Category:Turing complete
Category:Implemented
BurgerFlipper

BurgerFlipper is an esoteric programming language designed by User: Zemeckis on 5th November, 2016. It is directly inspired of Brainfuck, however, every other command, other than the loop commands, must be flipped to an alternate command of alike meaning. Along with this, the final output of your program will be "Thank you burger flipper!"
== Commands ==
Again, the compiler contains a flipper, that will flip every time a command other than loops is used. This means that normal, but pattern-incorrect characters are ignored until the proper flip is used.
The below table juxtaposes each brainfuck instruction with its BurgerFlipper equivalents, the latter of which bifurcates into two variants for the majority of the commands, the left token of which corresponds to the “unflipped” (original) state, while the right one pertains to the flipped.
Brainfuck	BurgerFlipper	BurgerFlipper
Brainfuck	Unflipped 	Flipped
> 	> 	f
< 	< 	b
+ 	+ 	a
- 	- 	s
. 	. 	o
, 	, 	i
[ 	[ 	[
] 	] 	]
Where in Brainfuck, the code to increment 10 bytes by 2 would look like this,
 ++>++>++>++>++>++>++>++>++>++
The BurgerFlipper code for the same action would look like
 +a>a+f+a>a+f+a>a+f+a>a+f+a>a+
== Examples ==
=== Hello, world! ===
BurgerFlipper's Hello World looks alike to Brainfuck's.
 +a+a+a+a+a[>a+a+a+a>a+a+a+a+a+f+a+f+ba+o>a.a+a+a+a.o+a+o>a+oo+a+o-s-s-s.s-s-s-s-o>a.
And the output would be
 Hello World!
 Thank you burger flipper!
=== Cat program ===
An infinitely repeating cat program is implemented in the following:
 ,o[,o]
==Purpose==
BurgerFlipper has about as much purpose as Brainfuck. Like Brainfuck, it is Turing Complete. It is very easy to convert Brainfuck to BurgerFlipper after the program is written in full, but to write a program exclusivley in BurgerFlipper takes a special kind of madness.
==Interpreter==
* Common Lisp implementation of the BurgerFlipper programming language.
Category:Joke languages
Category:Brainfuck derivatives
Category:2016
Category:Languages
Category:Turing complete
Category:Low-level
Burgercamp

Burgercamp is an accumulator-based output-only esoteric programming language based on Deadfish.
==Commands==
 i increments 7
 d decrements 3
 m multiplies by 5
 o outputs number
==Strange behaviour of m==
The number 25 should turn into 0, like Deadfish turning 256 into 0.
That means that:
 ididdm
Should turn into 0.
==Interpreter tests==
 ididdmo
Should output 0,
 iiiiiimo
Should output 210, and
 iiidiiidmo
Should output 55.
==Interpreter==
The following implementation is realized in the language Common Lisp:
 (defun interpret-Burgercamp (&optional (initial-code ""
 initial-code-supplied-p))
 "Launches the Burgercamp accumulator, contingently commencing with the
 INITIAL-CODE, and repeatedly queries the standard input for commands,
 until a completely empty line of length zero is issued, finally
 returning no value."
 (declare (type string initial-code))
 (declare (type T initial-code-supplied-p))
 (let ((accumulator 0))
 (declare (type integer accumulator))
 (flet ((process-commands (commands)
 (declare (type string commands))
 (loop for command of-type character across commands do
 (case command
 (#\i (incf accumulator 7))
 (#\d (decf accumulator 3))
 (#\m (setf accumulator (* accumulator 5)))
 (#\o (format T "~d " accumulator))
 (otherwise (terpri)))
 (when (= accumulator 25)
 (setf accumulator 0)))
 (values)))
 (loop
 initially
 (when initial-code-supplied-p
 (process-commands initial-code))
 for input
 of-type (or null string)
 = (prog2
 (format T "~&>> ")
 (read-line *standard-input* NIL "")
 (clear-input))
 until (or (null input) (zerop (length input)))
 do (process-commands input))))
 (values))
==See also==
* Burgercamp+
* Burgercamp+/burgercamp+-
Category:Output onlyCategory:Unusable for programmingCategory:2023Category:LanguagesCategory:TotalCategory:Implemented
Burgercamp+

Burgercamp+ is an addition to Burgercamp created by User:Tommyaweosme
== Commands ==
 i increment counter by 7
 e increment counter by 11
 d decrement counter by 3
 y decrement counter by 8
 m multiply counter by 5
 t multiply counter by itself
 o output counter
 a output counter as ascii
 u output counter as unicode
 r user input
 b same behavior as [ in brainfuck
 c same behavior as ] in brainfuck
 x save to extra counter
 y load from extra counter
 v put before a command to use extra counter
== 25 isn't broken anymore! ==
Exactly what it sounds like.
== Proof of turing-completeness ==
You don't need >2 cells if both cells are infinite.
 + idd
 - yi
 [ b
 ] c
 , r
 . a
 cell 2 variant v before
== A+B problem ==
 rvrbyivivdvdcvo
== Goals ==
The goals of this language were:
* add to burgercamp
* turing complete
* i/o
* print anything
* still be confusing as hell
* have a cheat shortcut that truttle1 will probably not want to use when they reviews this
==See also==
* Burgercamp+/burgercamp+-
Category:Turing completeCategory:LanguagesCategory:Unimplemented
Burgercamp/Constants

If you find a shorter way to represent a number please add it.
==words in burgercamp==
 midi (stores 11)
 idiom (prints 11 stores 55)
 dim (stores 20)
 dom (prints -3 stores -15)
 mid (stores 4)
 mod (prints 0, stores -3)
 odd (prints 0 stores -6)
 dod (prints -3 stores -6)
 dodo (prints -3,-6 stores -6)
 mom (prints 0 stores 0)
 i (stores 7)
 moid (outputs 0 stores 4)
==various ways to represent 7 from longest to shortest==
 iddmmiddmmiddmmiddmmiddmmiddmmdmiiddii
 iddmmiddmmiddmmiddmiddiddiddid 
 iddmmiddmmiddmmi
 iddmiddiddiddid 
 iddiddiddid
 iddmmiddmmi
 dmiiddii
 iddmmi
 i
==below and 0==
-25.
 dmiimm
-15.
 dm
-9.
 ddd
-8.
 dmi
-7.
 dmiidd
-6.
 dd
-5.
 dmiim
 idddd
Your pick.
-4.
 dmiid
-3.
 d
-2.
 dddi
-1.
 dmii
0.
 iddmm
==1-24==
1.
 idd
2.
 ididdd
3.
 iiidddddd
4.
 id
5.
 iddm
6.
 iiiddddd
7.
 i
8.
 iddi
9.
 iiidddd
10.
 iiddddm
11.
 iid
12.
 iiiddd
13.
 iiiiddddd
14.
 ii
15.
 iiidd
17.
 idmd
18.
 iiid
20.
 idm
21.
 iii
22.
 iiiidd
24.
 idmid
==26 and onward==
26.
 imddd
27.
 idmi
28.
 iiii
29.
 imdd
30.
 iiiiididdd
32.
 imd
35.
 im
39.
 imid
42.
 imi
46.
 imiid
47.
 ididddmmd
49.
 imii
50.
 iiddddmm
55.
 iiidiiidm
57.
 iiidiiidmi
64.
 imdd
67.
 imd
70.
 iim
71.
 iimidd
74.
 iimid
77.
 iimi
100.
 iiddddmmm
172.
 immd
175.
 imm
182.
 immi
210.
 imim
350.
 iimm
500.
 iiddddmmmm
875.
 immm
1000.
 ididddmmmmm
1085.
 imimim
4375
 immmm
5000.
 iiddddmmmmmm
5395.
 imimimddm
9997.
 iiiddddmmmmmmmd
10000.
 iddddmmmmmmm
10007.
 ididddmmmmmmmi
21875.
 immmmm
50000.
 iddddmmmmmmm
250000.
 iddddmmmmmmmm
1250000.
 iddddmmmmmmmmm
Category:Examples
Burgeria

Burgeria is an esolang written by User:Dtp09. This esolang takes code in the form of a burger. Specifically, a burger one can create in the hit 2010 flash game "Papa's Burgeria". Code is ran from the bottom of the burger to the top, similarly to how a burger is assembled.
Burgeria has a memory pointer, memory storage (5 pages each with locations 0-100)
An easily computable text variant of Burgeria has also been made in order to create an interpreter.
== Burger Elements (commands) ==
=== Element Text Formats ===
This is a table to represent burger elements in text form. this should be used for creating an interpreter.
Element 	Text Form
Top Bun 	topb
Tomato 	tmto
lettuce 	letc
Onion 	onin
Pickle 	pikl
Cheese 	ches
Bottom Bun	botm
Ketchup 	ktch
Mustard 	mstd
Mayo 	mayo
BBQ 	bbqu
Burger 	brgr
=== Top Bun ===
Top Bun will act as the end of the program. If your burger does not have exactly one top bun as the last element then it will not run.
=== Tomato ===
=== Lettuce ===
=== Onion ===
=== Pickle ===
=== Cheese ===
=== Bottom Bun ===
This will act as the start of the program. If placed in the middle of the burger, it will allow for conditionals, such as loops and if statements.
=== Ketchup ===
Initiate an "If equal" statement
=== Mustard ===
=== Mayo ===
=== BBQ ===
=== Burger Patty ===
Burger patties are probably the most complicated. They represent spaces in memory, depending on the evenness the patty was cooked at, and the length it has been cooked for.
There are 5 different pages of memory represented by the length cooked:
* Undercooked (page 0)
* Rare (page 1)
* Medium (page 2)
* Well done (page 3)
* Burnt (page 4)
and different locations in those memory pages from 0-100, depending on what percent of the bottom side of the patty has been cooked.
For example, a medium cooked burger cooked 55% on the bottom and 45% on the top, would result in page 2 address 55.
== Conditionals ==
Conditionals are represented with condiments which is a good way to remember
anybody who wants to add stuff to burgeria feel free because i do not feel like finishing this. Dtp09 (talk) 00:58, 22 October 2022 (UTC)
Category:Languages
Category:2022
Category:Turing complete
Category:Unimplemented
Category:Works-in-Progress