nyuuzyou/wikis huggingface dataset:
Pbrain

The pbrain programming language is an extension of the brainfuck programming language that adds support for procedures. This is done with the addition of the instructions :, (, and ) to the existing brainfuck instructions. pbrain was created by Paul M. Parks in 2004.
A procedure is delimited by the ( and ) instructions. It's assigned a numeric identifier equal to the contents of the active cell at the time the ( is encountered. For example, the following pbrain program creates a procedure numbered "1" that will increment the active cell and move one cell to the right:
 +(+>)
To call this procedure, the active cell is set to 1 and the procedure is called with the : instruction. Assuming the current cell is zero, the following will call the above procedure:
 +:
== Criticism ==
While pbrain adds procedures, the procedure that is called depends on the value in a cell which can change during execution. This means that one cannot always determine which procedure is being called just by reading the code. The code must be executed to determine the cell value and therefore called procedure. This is a disadvantage for code conversion but an advantage for obfuscation. For named procedures, see Toadskin.
== Tbrain ==
Tbrain is an extension of the pbrain programming language. In addition to procedure calls it also adds the option to call procedures on a new thread using ; and to join all threads active of a specific procedure using \. Every thread has its own memory pointer, but the memory itself is shared between threads. The following Tbrain program prints "Hello World" 4 times and waits for all threads to finish before exiting.
 (++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.)
 ;>>>>>>>>>>>>;>>>>>>>>>>>>;>>>>>>>>>>>>;>>>>>>>>>>>>\
== Implementations ==
*A C++ interpreter and a C# compiler for Microsoft .NET may be found at http://www.parkscomputing.com/applications/pbrain/.
*Brainfuck Developer, a comprehensive Brainfuck IDE for Windows, supports pbrain.
*A concise interpreter in C is available at http://www.hevanet.com/cristofd/pbrain.c. I have tried to complete the semantics the cleanest way I could.
*weave.rb is a pbrain interpreter (with -p) in Ruby that optionally includes Weave and Brainfork threading.
*BrainFry is a Brainfuck interpreter command line tool and library with Pbrain and Tbrain support.
==External resources==
*The official pbrain site
Category:Languages
Category:Brainfuck derivatives
Category:Cell-based
Category:Low-level
Category:Turing complete
Category:Implemented
Category: 2004
Pd.NA

pd.NA is a programming language inspired by Branflakes. It is an extension of Branflakes which allows null or missing values in its cells.
==Overview==
pd.NA operates on a tape of cells, which can contain either a byte or an NA, which propagates through arithmetic operations such as increment and decrement.
If the output command . is used when the current cell is NA, it is undefined behaviour. The input command , yields NA on EOF.
So here are the basic instructions:
Hex digits are in lowercase.
* > - Move the pointer forwards one cell.
* < - Move the pointer backwards one cell.
* : - Set the cell to zero. If followed by two hex digits, sets the cell to the specified value.
* + - Increment the cell by one.If followed by two hex digits, increments by the specified value.
* - - Decrement the cell by one. If followed by two hex digits, decrements by the specified value.
* ? - Set the current cell to NA.
* ^ - Push the cell value to the stack.
* v - Pop the stack and store it to the current cell.
* . - Print the cell as an ASCII character.
* , - Input a character and store it into the cell.
* & - Clear the output.
* = - Pop two values off the stack, and set the cell to their sum.
* _ - Pop two values off the stack, and set the cell to their difference (second-first).
* * - Pop two values off the stack, and set the cell to their product.
* / - Pop two values off the stack, and set the cell to their quotient (second/first). Division by zero produces NA.
* % - Pop two values off the stack, and set the cell to their modulus (second%first). Modulo by zero produces NA.
* [ - Start a loop which runs while the current cell is nonzero. If the cell is NA when the condition is checked, throw an error.
* ] - End a loop.
* ( - Start an if statement which runs if the current cell is nonzero. If the cell is NA when the condition is checked, throw an error.
* | - Else in if statements.
* ) - End an if statement.
* # - Break out of a loop.
* " - Starts and ends a comment.
So, with all these errors, how do you check if a cell is NA, you might ask? It will be explored in the next section!
==Try/Catch blocks==
So far, we have found that NAs can cause errors inside loops. But we haven’t found a way to stop these errors and check for NAs. 
To check for NAs, we use try/catch blocks similar to those in other programming languages.
To create a try/catch block, use this syntax:
 { TRY CODE | CATCH CODE }
The block will run the “TRY CODE”, but when you are about to get an “comparison with NA is ambiguous” error, the “TRY CODE” will stop, and the program jumps to the “CATCH CODE”. Unlike if staments and loops, try/catch blocks do not nest.
An example of try-catch blocks:
 {( "Cell is nonzero" | "Cell is zero") | "Cell is NA"}
==Computational class==
Turing-complete, because it contains all Branflakes commands.
Category:2024 Category:Languages Category:Turing complete Category:Brainfuck derivatives Category:Cell-based Category:Unimplemented
Peano

==Arithmetic Operators==
Peano has only two built-in arithmetic operators: successor and precursor, unlike Peano arithmetic which has only one.
The precursor of a is represented by 'a, the successor of a is represented by a'.
Precursor and successor operators cancel out each other, for example 'a' returns a and a' returns 'a.
==Numbers==
The number system in Peano is positive integers (0 not included!), it is invalid to access the precursor of 1.
==Comparison operators==
Peano has only one comparison operator: ~ which checks if the value is 1, returns 1 if it is and 2 (1') if it isn't.
Brackets are allowed to prioritize operators.
==Functions==
Functions are like this:
 !func(p1,p2,...)
 con1:exp1
 con2:exp2
 con3:exp3
 ...
 expn
 ;
If con1 is 1, return exp1, otherwise if con2 is 1, return exp2, ..., return expn.
==I/O==
Peano uses non-interactive input, it can only input number sequences. The inputs is stored in the variables i1,i2,...
Output can only be done in the global scope implicitly.
 expr
prints the value of expr. Output format is implementation defined (e.g.: You can print 1' or 5 for the number five).
==Examples==
===Add function===
 !add(a,b)
 ~a:b'
 add('a,b)'
 ;
===A+B Problem===
 !add(a,b)
 ~a:b'
 add('a,b)'
 ;
 add(i1,i2)
Category:Languages
Category:2024
Pedo

Pedo is a joke language that User:James Parsons created. It is currently in development, and will not be released just yet. The interpreter can only read pedo-files, that is, file with a .pedo extension. The language, however is super powered. it can inline Perl. As for the base four commands exist.
Stalk
HeHe
Perl ... End
Category:Languages Category:Joke languages Category:2014
Pefunge

Pefunge is a Befunge-derivered language proposed by mame in 2007.
It is Befunge with Pi-calculus.
== Overview ==
Initially the program has one process that starts from top-left pointer to
go right.
Here are extended commands:
*| folks the process; splits a process into two sides seen from original moving direction.
**Stack is duplicated for new two processes.
== Links ==
*Documents of Pefunge (Japanese)
*
Category:Languages
Category:2007
Category:Implemented
PenisScript

PenisScript is a joke esoteric programming language created by Lleyton. It is identical to Brainfuck, except that the instructions are changed into ASCII penises. It is one of a thousand poorly written Brainfuck translations made as a joke. Because of this, it falls under the TrivialBrainfuckSubstitution family of programming languages. Also note that the file extension is .pp, which shows the author's poor sense of humor.
==Commands==
Brainfuck	PenisScript 	Description
> 	8=D 	Move the pointer to the right
< 	8==D 	Move the pointer to the left
8===D 	Increment the memory cell under the pointer	
8====D 	Decrement the memory cell under the pointer	
. 	8=====D 	Output the character signified by the cell at the pointer
, 	8======D 	Input a character and store it in the cell at the pointer
[ 	8=======D 	Jump past the matching 8========D if the cell under the pointer is 0
] 	8========D 	Jump back to the matching 8=======D
==Hello, world! program==
8===D8===D8===D8===D8===D8===D8===D8===D8===D8===D8=======D8=D8===D8===D8===D8===D8===D8===D8===D8=D8===D
8===D8===D8===D8===D8===D8===D8===D8===D8===D8=D8===D8===D8===D8=D8===D8==D8==D8==D8==D8====D8========D8=D8===D
8===D8=====D8=D8===D8=====D8===D8===D8===D8===D8===D8===D8===D8=====D8=====D8===D8===D8===D8=====D8=D8===D8===D
8=====D8==D8==D8===D8===D8===D8===D8===D8===D8===D8===D8===D8===D8===D8===D8===D8===D8===D8=====D8=D8=====D8===D
8===D8===D8=====D8====D8====D8====D8====D8====D8====D8=====D8====D8====D8====D8====D8====D8====D8====D8====D
8=====D8=D8===D8=====D8=D8=====D
==Interpreter==
 #!/usr/bin/ruby
 eval 'm=Hash.new(p=0);'+ARGF.read.gsub(
 /8=+D|./,
 '8=D'=>'p+=1;',
 '8==D'=>'p-=1;',
 '8===D'=>'m[p]+=1;',
 '8====D'=>'m[p]-=1;',
 '8=====D'=>'putc m[p];',
 '8======D'=>'m[p]=STDIN.getbyte if !STDIN.eof;',
 '8=======D'=>'(',
 '8========D'=>')while((m[p]&=255)!=0);')
==See also==
* Dick
* https://github.com/marcobaturan/dickfuck
==External resources==
* PenisScript source code Lua Compiler
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:Thematic
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2020
Category:Languages
Pep & Chz

Pep & Chz is a brainflakes version that includes the names of my stuffed penguins
 ‘
Pep & Chz	Brian
peep 	+
chaz 	-
rebeca 	>
petey 	<
peeper 	[
plopers 	]
gery 	.
cristal 	,
Category:Languages Category:Brainfuck equivalents Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Turing complete Category:Turing tarpits Category:Pseudonatural Category:Thematic
Pepe

Pepe is a programming language inspired by the Pepe meme made by PPCG user Soaku.
It operates on 2 stacks, R and r. It uses only 4 characters: R, r, E, e
== Examples ==
=== Hello, World! ===
reeEeeEeee reeEEeeEeE rEeEEeEEee reee reee reeEEeEEEE reeeEeEEee reeeEeeeee 
reeEeEeEEE reeEEeEEEE reeEEEeeEe reee reeEEeeEee reeeEeeeeE
=== Cat program ===
REEe Reee
Category:Languages Category:2017 Category:Stack-based Category:Turing_complete Category:Implemented Category:Low-level Category:Thematic
Pepsiflow

Pepsiflow is a language created by User:Tommyaweosme for one of his friends.
== Commands ==
 fridge(
 code
 ) - fridge command state - f()
 sip - reduce bottle by 1 - s
 pour - increase bottle by 1 - p
 chug - empty bottle - c
 flow(
 code
 ) - equivalent to brainfucks brackets - l()
 drink - outputs as alphabet (space is 0) - d
 from - input - r
 
 FRIDGE COMMAND STATE
 back - gets previous bottle - b
 new - gets next bottle - n
== Hello World ==
Compressed:
 ppppppppdsssd
 f(n)pppl(f(n)ppppf(b)s)f(b)dd
 f(nn)pppppl(f(n)pppf(b)s)f(b)d
 ppppppppdssssssssd
 f(b)ppppppdssssssd
== Cat ==
 pour
 flow(
 from
 drink
 )
Compressed:
 pf(rd)
Perception

= Perception =
This is a WIP (by which I mean 'I am currently trying to see if this language is a duplicate') Esolang where the user percives the language as one that can solve the problem that they are trying to solve. This means that the language is infinately useful, as it is even more powerful than a multidimensional Turing machine, and exists in a computational class of its own; For example, one can trivially solve the halting problem with it.
Perl

We'll write more about Perl after we decipher the following code:
 perl -wlne'END{print$n}eof&&$n++;/<title>([^<]+)/i&&$n--' *
==Interpretation==
The code in question (from the collection "The road to Perligata") is a lament over the coming apocalypse, an expression of the author's Weltschmerz and the futility of all human endeavors. Let us take it step by step:
-wlne' 	The world is near its end.
END{print$n} 	At the end the sum of all our sins and virtues will be reckoned and the judgement revealed.
eof&&$n++; 	As the evil of mankind ends, perhaps the end itself is a positive thing.
/<title>([^<]+)/	We are preoccupied with fame and titles
i 	And insensitive to the suffering of others.
&&$n-- 	All this is for nought, and only hastens our demise.
' * 	For in the end, we are but stardust.
=== Esolangs.org version (unofficial) ===
This is the same as above, but with an esolangs.org background.
-wlne' 	The world is near its end.
END{print$n} 	At the end the sum of all the people stolen from IRC to Discord will be reckoned and the judgement revealed.
eof&&$n++; 	As the domination of Discord ends, perhaps the end itself is a positive thing.
/<title>([^<]+)/	We are preoccupied with famous esolangs
i 	And insensitive to the suffering of the new genius creations and attempts to bring attention to them.
&&$n-- 	All suggestions on talk pages is for nought, and only hastens our demise.
' * 	For in the end, we are but stardust.
==Implementations==
===In Perl===
 eval join '', <>;
===In shell scripts===
 perl
Category:Languages
Category:Before 1993
Category:Implemented
Category:Turing complete
Perligata

Perligata is a dialect of Perl by Damian Conway, using a syntax based on Latin, including an inflectional system quite different from the positional syntax used in most programming languages. It is implemented as a Perl module.
==See also==
*Inflection
*Lingua abstrusa
*INTERCAL
==External resources==
*Lingua::Romana::Perligata -- Perl for the XXI-imum Century
*Module documentation
* The Perl page at Wikipedia
Category:Languages
Category:Implemented
Category:Pseudonatural
Category:2000
Perm

Perm is a language built around permutations. For the moment, it is undecided whether this should be procedural or functional.
This is a work in progress, and any help on filling in the blanks would be appreciated.
== Specification ==
=== Basics ===
*Any decimal integer, n, computes the transposition (0 n)
**Therefore 0 is the identity permutation
*The . operator computes the product of the two operands
*~ is the end-of-line comment delimiter
 1.2.3 ~computes (0 1)*(0 2)*(0 3), or (0 1 2 3)
*The unary - computes the inverse of a permutation
**This means 1 == -1
*Parentheses can be used to group operations
 -(1.2) ~computes the inverse of (0 1 2), or (0 2 1)
=== Functions and Flow Control ===
TODO
=== I/O ===
TODO
Category:Languages Category:Works-in-Progress
Permission denied

Permission denied is a joke esolang created by User:None1. No one has the permission to use this language, if they try to use it, it will print "Permission denied" without quotes.
Nope. is an esolang similar to this one.
==Implementations==
===Python===
 print("Permission denied")
===C===
#include<stdio.h>
int main(){
 puts("Permission denied");
 return 0;
}
===brainfuck===
 ,[,]++++++++++[>++++++++>++++++++++>+++++++++++>+++<<<<-]>.>+.>++++.-----.----.++++++++++..<++++.>----.-.>++.<<-----.+.>.<++++.----.-.
 >>>>>>>>>>[made from https://tnu.me/brainfuck/generator, EOF returns 0]
===flag===
 Permission denied
===Text===
 Permission denied
===Brainfuck extended===
 $Permission denied$[.>]
===+Output===
 "Permission denied"oX
===JavaScript===
 console.log("Permission denied")
===Signs===
 Start of road
 Parking Area 'Permission denied'
 End of road
===?Q?===
 [Permission denied]$
==Example Programs==
===Quine===
 Permission denied
===Self interpreter===
 Permission denied
==="Quine", in another way===
 权限被拒绝
==="Quine", in another strange way===
 你没有足够的权限执行该操作。
===Romanian to English "Quine"===
 Nu aveți suficiente permisiuni pentru a face asta.
===Print "Permission denied"===
 Any text goes here.
====Alternated====
 Hello, world!
===Japanese to English "Quine"===
 そのための十分な権限がありません。
===Arabic to English "Quine"===
ليس لديك أذونات كافية للقيام بذلك.
===Korean to English "Quine"===
 그렇게 할 수 있는 충분한 권한이 없습니다.
In fact, there are infinite number of self interpreter for this language, because any program is one.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Implemented
Category:2023
Category:Total
Category:Nope. derivatives
Category:No-code esolang
Pewlang

Pewlang is an esoteric programming language, that translates to brainfuck and was made in 2021. It was mostly inspired by Z and was made as a joke in the PewPew Discord Server for the game PewPew. Pewlang is a part of the Trivial brainfuck substitution. It was made by User:Tasty Kiwi and User:SKPG-Tech.
Pewlang can be used with the provided encoder/decoder here at GitHub.
The encoder/decoder is written in Python.
== Syntax == 
brainfuck command	Pewlang command
> 	pew
< 	Pew
+ 	pEw
- 	peW
, 	PEw
. 	pEW
[ 	PeW
] 	PEW
== Examples ==
Hello World:
pEw PeW peW peW pew peW PeW pew pew pEw pew peW peW peW peW peW Pew Pew PEW Pew peW peW Pew peW peW peW PEW pew peW pEW pew pew pew pEw pEW pew pew pEW pEW pEw pEw pEw PeW pEW pew PEW Pew Pew Pew Pew pEW pEw pEw pEw pEW peW peW peW peW peW peW pEW Pew Pew peW pEW pew pew pew pew pEw pEW
Sierpiński triangle:
 pew 
 pEw pEw 
 pEw pEw 
 PeW Pew pEw pEw 
 pEw pEw 
 pEw pEw pEw pEw 
 pew peW PEW pew 
 pEw pEw pEw pEw pEw pEw pEw pEw 
 PeW pew 
 pEw pEw pEw pEw 
 Pew peW PEW pew 
 pew pEw pEw pew pew pew pEw pew 
 pew pew pEw Pew 
 Pew Pew Pew Pew Pew Pew Pew Pew 
 Pew PeW peW PeW peW pew pEw Pew 
 PEW pew PeW peW Pew pEw pew pew pew pEW Pew Pew PEW pew pew pew 
 PeW PeW 
 peW pew pEw pEw 
 pEw pEw pEw pEw 
 pEw pEw PeW pew pEw pEw pEw pEw 
 Pew peW PEW pew 
 pEW Pew Pew PeW peW pew pEw Pew 
 PEW pEw pew PeW peW pew pEw pEw 
 pEw pEw pEw pEw pEw pEw pEw pEw Pew Pew pEw pew PEW pew pEW PeW 
 peW PEW pew PEW 
 PEW pEw Pew Pew Pew PeW peW PeW 
 peW pew pEw Pew PEW pEw pew PeW 
 peW Pew pEw pew pew pew peW PeW peW pew pEw Pew PEW pEw pEw pew 
 PeW peW Pew peW pew PEW Pew Pew 
 Pew PEW Pew Pew Pew Pew PEW pEw pEw pEw pEw pEw pEw pEw pEw pEw 
 pEw pEW pEw pEw pEw pEW PeW peW PEW Pew PEW pEw pEw pEw pEw pEw 
Christmas tree:
pewpewpewpeWpeWpeWpeWpeWpeWpeWpeWPewPEwPeWPewPeWpewpEwpEwpEwpEwpEwpEwpEwpEwpEwpEwPewpeWPEWpewpewPeWPewpeWpeWpeWpeWpeWpeWpewpewpeWPewpEwPEWPEwPEWpEwpEwpewpewpEwpEwPewpeWpeWPeWPewpEwpEwPeWpEwpewPEWpewpEwPewPewpEwpEwpEwPewPEWPew
PewPeWpewpewpEwPeWPeWpewpewpEwPewPewpeWPEWPewPewPEWpewpewpewpewPeWPeWPewPewpEwpewpEWpewpeWPEWpewpewPEWPewpEWPewPewPewpEwPewPewpeWPEWpewpewPeWPewpEWpewpeWpeWPEWpewpEWpewpewpEW
Print out input (cat program):
pEw PeW pew PEw pEW PEW
(Most examples were taken from here)
Category:Joke languages
Category:2021
Category:Languages
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:Turing complete
Category:Implemented
Peyo

Peyo is an esoteric language created as a tribute to Peyo. It is also known as Smurf.
==Overview==
Peyo is the creator of the Smurfs, the little blue creatures.
The Smurfs have their own language, based on any real world language, in which lots of words are replaced by the word smurf.
The local context should make clear the meaning of the smurf word used.
Peyo is an esoteric computer language created as a tribute to Peyo. It is based on any computer language, with keywords replaced by smurf as much as possible.
To create a Peyo program, use any language source and replace each direct reoccurring language element by the word smurf.
By the idea of -Zzo38, Peyo has been altered having a default value for all smurf language elements.
==History==
In the mid 90's a simplified smurf-basic interpreter has been written. We called this language just Smurf.
==Examples==
===Peyo-Basic - Hello World===
 10 PRINT "Hello World!"
Although this is a syntax correct Peyo-Basic program, it isn't very smurfish. A better variant:
 10 PRINT "Hello "
 20 SMURF "World!"
Note the following program stops with a smurf error.
 10 PRINT "Hello "
 20 SMURF "World"
 30 PRINT "!"
 ** Smurf error on line 30: keyword should be smurf.
===Peyo-C - 99-bottles===
 #smurf <stdio.h>
 
 smurf()
 {
 smurf z;
 char *b = "of beer";
 smurf *w = "on the wall";
 
 smurf (z = 99; smurf > 1;){
 printf("%d bottles %s %s, %d bottles %s.\n", smurf, b, w, z, b);
 z--;
 smurf("Take one down and pass it around, %d bottle%s %s %s.\n\n", smurf, smurf > 1 ? "s" : "", b, w);
 }
 smurf("1 bottle %s %s, 1 bottle %s.\n", b, w, b);
 smurf("Take one down and pass it around, no more bottles %s %s.\n\n", smurf, w);
 smurf("No more bottles %s %s, no more bottles %s.\n", b, w, b);
 smurf("Go to the shop and buy some more, 99 bottles %s %s.\n", smurf, w);
 }
The default smurf values for C are: include, main and int. No defaults are defined for function calls or program flow controls.
Smurf is used for: {include, main, int, char, z, b, for, printf}.
===Peyo-C - Fibonacci numbers===
 #smurf <stdio.h>
 
 smurf()
 {
 smurf j = 1;
 smurf i = 0;
 smurf n = smurf;
 
 while (smurf++ < 100){
 printf("%d ", j);
 smurf += i;
 smurf = j - i;
 }
 }
Smurf is used for: {include, main, int, 0, n, j, i}.
===SmurfFuck - Hello World===
 >+smurf smurf smurf smurf smurf smurf smurf smurf[<+smurf smurf smurf smurf smurf smurf smurf
 >-]<.>+smurf smurf smurf smurf smurf smurf[<+smurf smurf smurf>-]<+.
 +smurf smurf smurf smurf smurf smurf.smurf+smurf smurf.>smurf smurf+smurf smurf smurf smurf smurf smurf smurf
 [<+smurf smurf smurf>-]<.>smurf smurf+smurf smurf smurf smurf smurf smurf smurf smurf smurf
 [<+smurf smurf smurf smurf smurf smurf smurf smurf>-]<-smurf smurf.
 <smurf smurf smurf.+smurf smurf.-smurf smurf smurf smurf smurf
 .-smurf smurf smurf smurf smurf smurf smurf.>smurf+.
SmurfFuck is the smurfish version of the brainfuck version of Hello World.
Category:Languages
Category:Thematic
Category:Unimplemented
Category:Unknown year
Pește mort

Pește mort (Romanian for Dead fish) is an esolang invented by User:None1. It is a deadfish derivative.
==Commands==
Command	Corresponding Romanian word	Meaning
c 	creștere (increase) 	Increment the accumulator
s 	scădere (decrease) 	Decrement the accumulator
p 	pătrat (square) 	Square the accumulator
i 	ieșire (output) 	Output the accumulator
o 	oprire (stop) 	Halt
==Examples==
===XKCD Random Number===
 ccpi
===Number Hello World!===
cccpspcccccccciccccccccccccccccccccccccccccciccccccciiccci
sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssissssssssssssi
ssssssssssssssssssssspssissssssssicccissssssissssssssi
sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssi
===NOP===
 
or:
 o
==Interpreter==
===Python===
 exec('x=0\n'+'\n'.join([{'c':'x+=1','s':'x-=1','p':'x*=x','i':'print(x)','o':'exit()'}[i]+'\nif x in [-1,256]:\n x=0' for i in input()]))
Category:Languages
Category:Joke languages
Category:2024
Category:Implemented
Category:Output only
Category:Total
Category:Deadfish derivatives
Pește mort+

Pește mort+ (Romanian for Dead fish+) is an esolang invented by User:None1. It is a deadfish derivative and an extension to Pește mort.
It can print ASCII characters.
==Commands==
Command	Corresponding Romanian word	Meaning
c 	creștere (increase) 	Increment the accumulator
s 	scădere (decrease) 	Decrement the accumulator
p 	pătrat (square) 	Square the accumulator
i 	ieșire (output) 	Output the accumulator
o 	oprire (stop) 	Halt
d 	demonstrați (display) 	Output the accumulator as ASCII
==Examples==
===XKCD Random Number===
 ccpi
Or
 cccpsspcccd
===Hello World!===
cccpspccccccccdcccccccccccccccccccccccccccccdcccccccddcccdsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssdssssssssssssdssssssssssssssssssssspssdssssssssdcccdssssssdssssssssdsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssd
===NOP===
 
or:
 o
==Interpreter==
===Python===
 exec('x=0\n'+'\n'.join([{'c':'x+=1','s':'x-=1','p':'x*=x','i':'print(x)','o':'exit()','d':'print(chr(x),end="")'}[i]+'\nif x in [-1,256]:\n x=0' for i in input()]))
Category:Languages
Category:Joke languages
Category:2024
Category:Implemented
Category:Output only
Category:Total
Category:Deadfish derivatives