nyuuzyou/wikis huggingface dataset:
CES

The CES is a Python program written by Monochromeninja (talk) to compile Character-based ESolangs into Python interpreters.
Note: This page may change at any time due to updates to CES. The CES update log can also be found.
== Documentation ==
A .ces file is made up of multiple sections.
=== Sections ===
Sections are in all caps and are set off by two pound signs and a space on either side, like ## THIS ##. Every section except INSTRUCTIONS is optional.
==== UTILS ====
Each item on its own newline here is imported from utils.py. It is useful for adding abstract utilities, such as a Tape.
==== DECLARE ====
This is where you can declare variables that are used throughout the program.
==== INSTRUCTIONS ====
This is where you can define characters and their functions. Simply write the character followed by a space followed by the actual code. If you need multiple lines, simply indent the code on its own set of lines instead of spacing it out.
==== BETWEEN ====
This section is Python code that is to be used after each instruction but before the IP is changed.
=== Special items ===
* CODE: The program code
* JUMPS: Used with JUMP. The jump dictionary to use.
* GET_CHAR(x): Gets a character from input, using character x if none is given.
* JUMP: Jump using the jump dictionary.
* HALT: Stop executing.
* __ip: The instruction pointer as a number.
=== Usage ===
Simply run char_esolang.make_char_esolang on the filename sans extension. Example: make_char_esolang("brainfuck"). This will compile it into a Python file with the same name with a function of the same name with "run_" prepended. Example: starting with running the function on brainfuck.ces, a file brainfuck.py is generated with a function run_brainfuck.
== Source code ==
The CES source is on another page, while the CES files are on yet another page.
== Notes ==
If you think you're up to the challenge, go to CES files to make your own .ces file. Also please make sure that it works properly before posting. Thank you!
All CES pages:
* CES (you are here)
* CES files
* CES source
* CES updates
Category:Meta-languages Category:Implemented Category:Languages
CES files

== Introduction ==
This page has been dedicated to .ces files. Please add your own! If you don't know what this is referring to, then check the page on CES.
== Brainfuck ==
## UTILS ##
Tape
get_jump_dict
## DECLARE ##
tape = Tape(0)
JUMPS = get_jump_dict(CODE, {"[":"]"})
## INSTRUCTIONS ##
+ tape.current = (tape.current+1)%256
- tape.current = (tape.current-1)%256
> tape.move_right()
< tape.move_left()
, tape.current = ord(GET_CHAR(chr(0)))
. print(chr(tape.current), end="")
[ if tape.current == 0: JUMP
] if tape.current != 0: JUMP
== Deadfish ==
## DECLARE ##
acc = 0
f = lambda acc: 0 if acc in [-1,256] else acc
## INSTRUCTIONS ##
i acc = f(acc+1)
d acc = f(acc-1)
s acc = f(acc**2)
o print(acc,end="")
== Deadfish 2 ==
## DECLARE ##
acc = 0
s = ""
## INSTRUCTIONS ##
i acc += 1
d acc -= 1
s acc **= 2
o print(acc,end="")
O print(s,end="")
c print(chr(acc),end="")
n acc = 0
r s = input()
h HALT
== Poohbear ==
I'm not sure if this is correct -- can someone please check? Preferably the devs of Poohbear? (I don't understand C)
## UTILS ##
BoundedTape
get_jump_dict
## DECLARE ##
tape = BoundedTape(0,30000)
JUMPS = get_jump_dict(CODE,{"W":"E"})
copied = 0
## INSTRUCTIONS ##
+ tape.current = (tape.current+1)%256
- tape.current = (tape.current-1)%256
> tape.move_right()
< tape.move_left()
c copied = tape.current
p tape.current = copied
W if tape.current == 0: JUMP
E if tape.current != 0: JUMP
P print(chr(tape.current),end="")
N print(tape.current,end="")
T tape.current = (tape.current*2)%256
Q tape.current = (tape.current**2)%256
U tape.current = int(tape.current**.5)
L tape.current = (tape.current+2)%256
I tape.current = (tape.current-2)%256
V tape.current = tape.current//2
A tape.current = (tape.current+copied)%256
B tape.current = (tape.current-copied)%256
Y tape.current = (tape.current*copied)%256
D tape.current = tape.current//copied
== Underload ==
## UTILS ##
get_jump_dict
Stack
## DECLARE ##
JUMPS = get_jump_dict(CODE, {"(":")"})
stack = Stack()
## INSTRUCTIONS ##
~
 item1 = stack.pop()
 item2 = stack.pop()
 stack.push(item1)
 stack.push(item2)
:
 item = stack.pop()
 stack.push(item)
 stack.push(item)
! stack.pop()
*
 item1 = stack.pop()
 item2 = stack.pop()
 stack.push(item2 + item1)
(
 start = __ip
 JUMP
 stack.push(CODE[start+1:__ip])
a stack.push("(%s)"%stack.pop())
^ CODE = CODE[:__ip+1] + stack.pop() + CODE[__ip+1:]
S print(stack.pop(),end="")
## BETWEEN ##
JUMPS = get_jump_dict(CODE, {"(":")"})
== PlusOrMinus ==
## DECLARE ##
x = 0
## INSTRUCTIONS ##
+ x=(x+1)%256
- print(chr(x),end=""),x=(x-1)%256
== RUNNER ==
## DECLARE ##
number = 0
tape = ""
translate = ["R", "U", "N", "E", "O"]
## INSTRUCTIONS ##
R number = RUNNER(tape);tape = ""
U tape += translate[number % 5]
N number -= 1
E number += 1
O print(number)
return number
== Notes ==
All CES pages:
* CES
* CES files (you are here)
* CES source
* CES updates
Category:Examples
CES updates

This page is for CES updates. The CES files and CES source can also be found on the wiki.
* 1.0: 3/19/2021
 CES created
* 1.1: 3/22/2021
 BETWEEN section added
== Notes ==
All CES pages:
* CES
* CES files
* CES source
* CES updates (you are here)
Category:Implementations
CFUCK

=Introduction=
==English==
The word "FUCK" means "艹" in Chinese, so "CFUCK" means "C艹", or C++.
==简体中文==
“FUCK”的意思就是“艹”，所以“CFUCK”就是“C艹”(C++)。
=External resources=
*(English) C++ - Wikipedia
*（简体中文）C++ - 维基百科，自由的百科全书
=See also=
* B#
Category:Languages
Category:Joke languages
CFuck

CFuck is, like its name, a C extension to brainfuck. It is invented by User:None1.
==Data structure==
It also has a byte queue.
==Commands==
All the original commands are the same, but there are extra commands:
 Extra commands
Command	Description 	
 	Push a byte (current cell) onto the queue 	
 	Pop a byte and store it in current cell 	
 	Argument/Return type 	Description
b 	Pop a byte and current argument is the byte 	
i/I 	Pop 4 bytes, and compose a little/big endian 4-byte integer from it 	
l/L 	Pop 8 bytes, and compose a little/big endian 8-byte integer from it 	
s 	Pop bytes until front of queue is a zero, compose a C-Style string from it 	
v 	void, doesn't push anything when used as a return type, and it is invalid to use it as an argument type	
==Examples==
===Wait for a key===
 @"msvcrt.dll"getch()v
===Wait for a key and print it===
 @"msvcrt.dll"getch()b%.
===Message box===
 ********++++++++[>++++++++<-]>+***>*<***>*****@"user32.dll"MessageBoxA(Lssi)v
It creates a message box with its title and content both AAA.
Category:Languages
Category:Brainfuck derivatives
Category:Queue-based
CGOLOE

CGOLOE is a esolang made by User:yayimhere. its name os short for Conways Game Of Life Oriented Esolang. its a esolang made to compute conways game of life and is therefore also turing complete(since it can compute conways game of life and conways game of life is turing complete)
== memory ==
memory is a 2d infinite matrix/grid. it is designed like the normal euclidean coordeinate system. the memory pointer starts at coords (0, 0)
== syntax ==
the syntax of CGOLOE
 syntax
symbol(s)	descriptioj
←↑→↓ 	move around the memory
∆ 	loop over every cell in the relevant square and do the following instructions until a relevant seperator
∇ 	Represents the sum of all neighbor cells to current cell
∂ 	If the following if statement is true do the code after the seperator else it will do the code after the second seperator until the third seperator
ω 	Set the current cell to the following number
[] 	Loop whats in the brackets until the current cell is the following number
+ 	Increment current cell by 1
- 	decrement current cell by 1
⍋ 	print the current cell as a number
⍒ 	print the current cell as a ascii char
⍠ 	set current cell to user input
⌥ 	put in the following matrix into the memory such that its center will be at coords (0, 0). if it has no 0 it will be the lower right cell that will go to (0, 0)
⟐ 	Seperator
⨀ 	Relevant seperator
ⁿ 	represents current cell
⁐ 	no op
( 	nested seperator. the more ('s the deeper the nesting
‱ 	store the following matrix into the proceding letter
{} 	do the instructions in the brackets in the following matrix
"" 	store the ascii values of each char in the string into each cell from the current cell and to the left
=== if statements ===
the syntax of an if
 Caption text
Header text	Header text
== 	is the left number equal to the right
!= 	is the left side not equal to the right
> 	is the left side more than the right
< 	is the left side less than the right
%! 	is the following number even
=== matrix ===
the structure of a matrix is: 
 ⎡⎤
 ⎢⎥
 ⎣⎦
so this is a valid matrix for example:
 ⎡2 3 5⎤
 ⎢4 6 1⎥
 ⎣3 4 8⎦
this is also valid:
 ⎡4 55⎤
 ⎢8 8⎥
 ⎣9 7⎦
this is invalid:
 ⎡4⎤
 ⎢6 6⎥
 ⎣1⎦
this is invalid:
 ⎡6⎤
these are some examples of valid and invalid matricese.
the rules are:
* for every ⎡ there must exist a ⎣ below(and also with the rotated ones)
* there must only be 1 of each corner
* there must be 2 rows
* each row needs to be equally wide
== programs ==
conways game of life(needs to have a matrix put in first which is not in the code):
 [∆∂ⁿ==0⟐∂∇==3(ω1(⁐(⟐⁐⟐∂ⁿ==1⟐∂∇<2(ω0(⁐⟐⁐⨀∆⍋⨀]200
truth-machine:
 ⍠[⍋]0⍋
Balanced Parentheses(only normal brackets):
 false‱⎡102 97 108 115 101⎤⎣0 0 0 0 0⎦true‱⎡116 114 117 101⎤⎣0 0 0 0⎦A‱⎡0⎤⎣0⎦ω4↑ω5↓→"(()(()))"[→]0ω300[←]4→[∂ⁿ==40⟐↑+↓→⟐∂ⁿ==41(↑+↓→(⁐⟐⁐]300↑[{+}A←]{∂ⁿ%!⟐{∆⍒⨀}true⟐{∆⍒⨀}false}A
Category:Languages Category:Turing complete Category:Cell-based Category:Unimplemented
CHIQRSX9+

CHIQRSX9+ is a supposedly Turing-complete extension to HQ9+ designed by Ørjan Johansen in April 2002. It implements the following commands:
Command	Description
C 	Copies input to output.
H 	Prints "Hello, world!"
I 	Interprets input as program source.
Q 	Prints the program source code.
R 	Encrypts input with ROT-13.
S 	Sorts input lines.
X 	Makes the programming language Turing-complete. How this is supposed to be achieved is not clearly specified. The original interpretation just randomly adds a number to each letter and runs a perl. The updated one by User:ChristopherPeart adds 7 to each char then runs as perl making it TC and ruining the joke.
9 	Prints the lyrics to "99 Bottles of Beer on the Wall."
+ 	Increments the accumulator.
==Examples==
===Hello, world!===
 H
===99 Bottles of Beer===
 9
===Cat===
 C
===CHIQRSX9+ Interpreter===
 I
===Quine===
 Q
==External resources==
*The original CHIQRSX9+ interpreter in Perl
*Author's homepage
*Updated interpreter
Category:Languages
Category:Joke languages
Category:Implemented
Category:2002
Category:Unusable for programming
CHR

Constraint Handling Rules is a serious logic programming language (or set of related languages), that may be of interest to esolang fans.
Essentially, CHR does constraint rewriting. One form of constraint rewriting is simplification, such as transforming an if-and-only-if into two implications, one in each direction. Simplification eliminates the starting constraints. Another form of constraint rewriting is propagation. Given two implications A=>B and B=>C, one can deduce A=>C. Propagation does not eliminate the starting constraints. So called "simpagation" combines these two paradigms, eliminating some but not all of the starting constraints.
A recent scholarly survey article is As time goes by: Constraint handling rules -- A survey of CHR research between 1998 and 2007 (2009) by by Jon Sneyers, Peter Van Weert, Tom Schrijvers and Leslie De Koninck.
==External resources==
* Constraint Handling Rules at Wikipedia
* Documentation of SWI-Prolog's implementation of CHR
* CCHR, an implementation of CHR compiling to C
Category:Languages Category:Turing complete Category:Implemented
CIOL

CIOL is a language developed by Moon_, and is designed to be fast, and efficient, in its own way
== Operations ==
* p | Moves the pointer up one
* P | Moves the pointer down one
* + | Increases the value under the pointer
* - | Decreases the value under the pointer
* o | Outputs the character equivilent of the value under the pointer
* i | takes input
* [ | Ignored, however, ] uses this for a brainfuck like loop (like)
* ] | Goes back until it hits a [, if it hits another ] before it hits a [, it takes one more [ to stop the loop
* / | Pushes the value under the pointer to the register specified by the next value under the pointer (R1-R3)
* \ | Pops the value register specified by the next value under the pointer to the value under the pointer (R1-R3)
* a | adds R1 and R2 together and puts the result in R3
* s | subtracts R1 from R2 and puts the result in R3
* d | divides R1 by R2 and puts the result in R3
* m | Multiplys R1 by R2 and puts the result in R3
* * | Terminates the program
* j | Jumps forward n spaces
* J | Jumps backward n spaces
* r | prints out the data in the source until it hits a ;
* R | Prints out the next character in the source
== Examples ==
First two quines, from fizzie. Initially without the R instruction:
 ​+jr++++[-p++++++++p+++++++++++++++++++++PP]p+++op+o++++++++oP[-P++p]P---------J------------------o+++++++++++++++o* this is a rather suboptimal quine here;J
And obviously much more simply with it:
 +jrR+RjRr+++++[-p++++P]p_J----[-P+++p]P-oRJ*done;J
Hello, World!
 rHello, World!;
Echo
 +++j[-oi+]
Reverse echo
 ++j[pi+]P[-oP]
Category:Languages
Category:2016
Category:Cell-based
Category:Turing complete
Category:Brainfuck_derivatives
Category:Implemented
CJProg

CJProg is an Esolang invented by PSTF and his AI-friend Wenxinyiyan.
== Syntax ==
=== Basic structure ===
==== Comment ====
# Use 注意： as Single Comment.
# Use 注意：[[[[ skrjhxsfksjrgngcyfsgf ]]]] as Multi Comment.
==== Variable ====
# Use 変数 to define a variable.
# There are ten usable types: 整数, 小数, 文字, 未定義(Void), 真偽値, 文字列, リスト(List), 辞書, 構造体, 対象.
==== I/O ====
# Use ユーザーからの入力 as user input to be a value.
# Use 出力 as output function.
=== Conditions ===
# "もし……そうしたら……然も無くば……終わり。" is "If……then……else……end.".
=== Loop ===
# "反復ループ (制御変数初期化ステートメント、条件付き判断ステートメント、インクリメンタル ステートメント)" is for(type var = init; condition; increase) in C++.
# Use 中断 to break a loop.
# "条件付きループ (条件式) {ステートメント}" is while(condition){statement} in C++.
=== Function ===
Function can be defined as this syntax(for example): 
関数 整数型 主な過程()
{
 注意：主要関数にステートメントを書いてください！
 返す 0；
}
=== Class ===
This programming language actually emulates C++, so it is also an object-oriented programming language.
対象 円
{
 整数型 半径；
 
 作成(整数型 ぜ) 注意：この関数は、円型のオブジェクトを構築します。
 {
 半径 = ぜ；
 }
 
 小数型 面積(整数型 ぜ) 注意：この関数は、円の面積を計算するメンバー関数です。
 {
 返す ぜ * 円周率；
 }
 
 破棄(引数は必要ありません) 注意：これは、以前に作成された円を破壊するデストラクタです。
 {
 注意：リソースをクリーンアップする (存在する場合)
 }
}
関数 整数型 オブジェクトの使用()
{
 円 皿 = 円の作成(3)；
 出力円の作成("この円の面積は", 皿.面積, "です。");
 円の破棄()；注意：次に、このプレートを細かく砕きます。
 返す 0；
}
== Example Programs ==
=== こんにちは、プログラミングの世界！ ===
#徴兵する 《標準ライブラリ》
関数 整数型 主な過程()
{
 出力("Hello, world!")；
 返す 0；
}
=== Cat program ===
#徴兵する 《標準ライブラリ》
関数 整数型 主な過程()
{
 文字列型 inputString；
 出力("Input a string: ")；
 入力(inputString)；
 出力("You inputted \"", inputString, "\".\n")；
 返す 0；
}
== See also ==
* 日本語
== Categories ==
Category:Languages
Category:2024
Category:CJK
Category:High-level
Category:Generated by AI
CJam

CJam is a stack-based programming language inspired by GolfScript. It was created by aditsu in 2014. The official interpreter is written in Java.
== Instructions ==
Consult the CJam cheat sheet (PDF) by User:Lynn.
== Example code ==
===Hello, world!===
 "Hello, world!"
===Cat program===
 q
===Truth-machine===
 ri{_p}h;
== Turing-completeness ==
CJam is Turing-complete. To show this, writing a Brainfuck interpreter wouldn't be too hard. A lazier proof is to say that the Underload commands :()^ correspond to the CJam commands _{}~.
== External resources ==
* CJam homepage
Category:2014
Category:Stack-based
Category:Implemented
Category:Turing complete
Category:Golfing language
Category: Languages
CJam-Flavored Underload

CJam-Flavored Underload is a dialect of Underload that makes it a proper subset of CJam.
== Instructions ==
Underload Command	CFU Version
(x) 	"x"
: 	_
~ 	\
! 	;
* 	+
S 	o
a 	`
^ 	~
The first and sixth translations are not perfect matches; nested quotes and backslashes may need to be escaped.
== Example ==
Here is the Fibonacci program from the Underload wiki page translated into CFU:
"\"\"\"+\"""\\_~_o+`\\~`\\;\\+\\_\"/\"o~"_~
== Interpreter ==
Since CFU is a subset of CJam, any CJam interpreter can also interpret CFU. There is an interpreter located on cjam.aditsu.net, as well as on Try it Online!
Category:Languages
Category:Implemented
Category:Turing complete
Category:Stack-based
Category:2017
Category:Esoteric subset
CLEB

CLEB (Cell-based lightweight esoteric bytecode) is a variation of brainfuck, with emphasis on file size. CLEB is a language used to challenge programmers to create a program using the least amount of bytes possible.
Along with the 8 standard brainfuck commands, there are 8 more that are for the sole purpose of making programs smaller or math easier. The 8 extra commands are:
# { -- Beginning of an if statement (if (cell == 0))
# } -- The end of said statement
# ; -- Clear current cell
# : -- Fill current cell (255)
# * -- Double current cell
# / -- Half current cell
# \ -- Print current cell number value
# | -- Get number from user
There are two interpreters for CLEB, one in Java, and one in Python. The zip file with both of them and their source code is here.
Almost all syntax rules in brainfuck apply to CLEB, the only one not applying is [comments like this.] Although, every character that is not like a command is a comment in both interpreters. In the Python interpreter, there are 100 cells, in the Java, 1000. This is easily changed in the source code.
Category:Languages
Category:2015
Category:Cell-based
Category:Turing complete
Category:Brainfuck derivatives
Category:Implemented
CLFCE

CLFCE (or Computer Language For Code Execution. also pronounsed as self-see) is a esoteric programing language created by User:Ractangle
== Commands ==
Name 	Meaning
compile [...] 	Used as a way to execute an array of code.
therm(...) 	Print command.
if(...) then(...) 	If command.
else(...) 	Else command.
elseif(...) 	Else if command.
loop(...) <stopelse(...)>	Loop command.
input(...) 	Input command
<varname>(<varval>) 	Creates/Edits a variable
== Examples ==
=== Hello World ===
 compile [1]
 therm("Hello, world!\n")
=== Infinite Loop ===
 compile [1]
 loop(therm("inf"))
=== Truth-machine ===
 compile [1-3]
 i(input("Input a 1 or an 0 here"))
 if(i=0) then(therm(0))
 else(loop(therm(1)))
=== Deadfish implementation ===
 compile [1-10]
 a(0)
 loop(
 c(input(">"))
 if(c="i") then(a=a+1)
 elseif(c="d") then(a=a-1)
 elseif(c="s") then(a=a*a)
 elseif(c="o") then(therm(a))
 if(a=256) then(a=0)
 elseif(a=-1) then(a=0)
 )
===Fixed Repeating Output===
 compile [1-6]
 i(input())
 loop(
 i(i-1)
 therm(1)
 ) stopelse(i=0)
 therm(0)
Category:Languages Category:Unimplemented Category:2024
CLUVM

CLUVM (Crazy Layered Unprotected Virtual Machine) is an imaginary Virtual Machine, that is based on CLM.
==Concept==
The goal of CLUVM is, to be as accessible as possible, thus storing almost everything inside of the CLM.
Each CLUVM contains a default structure, that can be modified by using CLML
==Structure==
===Main Layer===
Layer 	Description
0: Storage	main storage, has an initial length of 1
1: Pointer	stores multiple pointers (layers that descripe a path), is used for certain commands that require a pointer
2: Input 	stores cells, which together make up the standard input. Data stored here was inputted by the user
3: Output 	stores multiple layers, each representing a different output type. Data stored in here will be displayed to the user
4: Data 	stores some information, that can be accessed
5: Files 	stores multiple layers, each representing a file (programs are stored here)
6: Control	holds the information required to run CLUVM
Category:Languages
COBOL

:This is not the page of the non-esoteric language COBOL.
COBOL is an esoteric programming language designed by User:IslandHopper973. It stands for "Card Orientations Based Object Language", and it takes the form of Player, Game and Deck definitions. The Deck definition consists of a list of playing cards, each of which is linked to some instruction.
==Example programs==
The cat program:
 Players: Jim, Bob
 Game 1
  
 3H,8H,5D,1S,6D,KC,QC,KC,4H,KC,1S,KC,7D,KC,6H,KC,
 1S,KC,1S,KC,1C,KC,4D,KC,4D,KC,8H,KC,2S,KC,6H,KC,
 1S,KC,5D,KC,6D,KC,5H,KC,7H,KC,1H,KC,QC,KC,1S,KC,
 2C,KC,4D.
A program which prints the lyrics to 10 Green Bottles (a shorter alternative to 99 Bottles of Beer on the Wall):
 Players: Jim
 Game 1
  
 4H,1S,10S,6H,1S,5D,6D,8D,1S,8D,1S,QH,7Q,1H,QC,8R,1H,QC,QR,1H,QC,KH,QQ,1H,QC,
 5R,1H,QC,3Q,1H,QC,KH,QQ,1H,QC,1S,2H,QC,KH,QQ,1H,QC,8D,2S,KH,QQ,1H,QC,10R,
 1H,QC,4Q,1H,QC,8R,1H,QC,JR,1H,QC,6Q,1H,QC,2Q,1H,QC,KH,QQ,1H,QC,1R,1H,QC,2R,
 1H,QC,2R,1H,QC,5R,1H,QC,2Q,1H,QC,3R,1H,QC,7Q,1H,QC,10Q,1H,QC,1R,1H,QC,6Q,1H,
 QC,6Q,1H,QC,KR,1H,QC,KH,QQ,1H,QC,3Q,1H,QC,1R,1H,QC,6Q,1H,QC,6Q,1H,QC,KH,QR,
 1H,QC,1S,2C,QH,10Q,1H,QC,4Q,1H,QC,3R,1H,QC,9Q,1H,QC,3R,1H,QC,KH,KR,1H,QC,
 6Q,JC,1H,QC,1H,QC,KH,QQ,1H,QC,1Q,1H,QC,3R,1H,QC,8D,1S,KH,9Q,1H,QC,KH,QR,JC,
 1H,QC,1H,QC,4D.
  
 Fixture: 1
  
 Players: Jim
 Game 1
  
 6H,1S,2H,QC,KH,QQ,1H,QC,8D,2S,1S,2C,1D,1S,1C,2D,10R,1H,QC,4D,3D,1D,2D,KC,4D,
 3D,10R,1H,QC,4D,4D,KH,QQ,1H,QC,8D,3S.
  
 Fixture: 2
  
 Players: Jim
 Game 1
  
 4R,1H,QC,9Q,1H,QC,3R,1H,QC,3R,1H,QC,7Q,1H,QC,KH,QQ,1H,QC,1Q,1H,QC,8R,1H,QC,
 10Q,1H,QC,10Q,1H,QC,6Q,1H,QC,3R,1H,QC.
  
 Fixture: 3
  
 Players: Jim
 Game 1
  
 10R,1H,QC,10Q,1H,QC,1R,1H,QC,7Q,1H,QC,2Q,1H,QC,5R,1H,QC,7Q,1H,QC,4R,1H,QC,
 KH,QQ,1H,QC,8R,1H,QC,7Q,1H,QC,KH,QQ,1H,QC,10Q,1H,QC,4Q,1H,QC,3R,1H,QC,KH,
 QQ,1H,QC,QR,1H,QC,1R,1H,QC,6Q,1H,QC,6Q,1H,QC,KH,QR,1H,QC.
==External resources==
* 
Category:Languages
Category:Stack-based
Category:Unknown computational class
Category:Unimplemented
Category:2007
COPIED!

COPIED! is a esolang made by yayimhere base around copying numbers on a stack
5 basic commands:
 commands
symbol	description
$ 	copy top element
& 	discard top element
- 	negate top element
+ 	add together the two top values
* 	multiply the two top values
(...) 	loop whats in the brackets while there are no 0's on the stack
, 	print top value as a ascii char
. 	print the top value
Category:Languages Category:Stack-based
COPY WITH @

COPY WITH @ or CW@ is a esolang(made by User:Yayimhere) where you copy values of a stack and increment and decrement them. the stack starts with a 1 on it.
 SYNTAX
symbol	description
@ 	copy top of stack
# 	discard top of stack
! 	output the top of the stack with out popping the value
; 	output the top of the stack as a ascii char
+ 	increment top of the stack
- 	decrement top of stack
? 	take user input and push onto stack
{ 	jump to corresponding } if the top of the stack is a 0
} 	jump to corresponding { if the top of the stack is not 0
↷ 	put the top of the stack to the bottom
== Examples ==
here are some examples:
truth-machine
 ?{!}!
and a lot longer one:
 -@@+↷↷+{↷{↷↷↷↷+↷↷+↷↷↷-}↷↷↷↷{↷↷+↷↷↷↷-}↷↷{{-}↷↷↷↷#?↷↷↷↷↷↷↷↷+↷↷↷↷↷↷+↷↷↷↷{↷↷{-}↷+↷↷↷↷↷↷-}↷↷↷{↷↷↷↷↷↷+↷↷↷-}↷↷{↷↷↷{-}↷↷{-}
 ↷↷↷↷↷↷↷↷↷↷↷↷↷↷↷↷{↷↷↷↷↷↷↷↷+↷↷+↷↷↷↷↷↷↷↷↷↷↷↷↷↷-}↷↷↷↷↷↷↷{↷↷↷↷↷↷↷↷↷↷↷↷↷↷+↷↷↷↷↷↷↷-}↷↷{-}}↷↷↷↷↷↷↷↷↷↷↷↷{-}↷↷↷↷↷↷}↷↷↷{↷↷↷↷+↷↷+↷↷
 ↷-}↷↷↷↷{↷↷+↷↷↷↷-}↷↷{{-}↷↷↷↷{;}}↷↷+↷↷+↷↷{↷↷↷↷-↷↷+↷↷↷-}↷↷↷↷↷↷{↷↷↷+↷↷↷↷↷↷-}↷{-↷↷+↷↷{↷↷↷↷↷↷-↷↷+↷-}↷↷{↷+↷↷-}↷↷↷↷{↷-↷↷
 {-}}↷{↷↷↷+↷↷↷↷↷↷-}↷}↷↷↷↷{-}↷↷↷↷{↷↷↷↷+↷↷+↷↷↷-}↷↷↷↷{↷↷+↷↷↷↷-}↷↷{{-}↷↷↷↷;↷↷}↷↷↷{↷↷↷↷+↷↷+↷↷↷-}↷↷↷↷{↷↷+↷↷↷↷-}↷↷{{-
 }↷↷↷{-}↷↷{-}↷↷↷↷}↷↷}
Looping counter:
 -@@++{------↷↷+↷}↷↷-@;{@:}
Numeric cat program:
 ?!
== Computational class ==
COPY WITH @ is Turing-complete because it can almost directly implement all the commands of 3-cell brainfuck (at the start of the program it is easy to create a stack of 3(-@@) cells with the value 0, then < can be implemented as ↷ and > can be implemented as ↷↷, with the other commands having direct equivalents as one- or two-command combinations (substitution system)).
== External resources ==
* Github repo for an interpreter (the ; command doesn't work for some reason if you can fix it plz do)
* a human written interpriter by User:Ractangle (doesn't have loops bult in)
Category:Languages
Category:Turing complete
Category:Implemented
Category:Stack-based