nyuuzyou/wikis huggingface dataset:
Paintfuck+

This language is by User:Poolala, and is an extension of the Paintfuck language.
Each cell is represented as an RGB code, and the colors wrap. (FF to 00, 00 to FF)
The cell array is the same as Paintfuck's.
The operations are:
Operation	Description
n 	Move north
s 	Move south
w 	Move west
e 	Move east
+ 	Increment the current cell's current color
- 	Decrement the current cell's current color
% 	Cycle current cell's color (every cell starts at R, and the order of cycling is R-G-B-R...)
[ 	While current cell's color is nonzero...
] 	End while
i.e. %- would make the current cell green.
==See also==
* Paintfuck
* Paintfuck++
Category:2013
Category:Brainfuck derivatives
Category:Cell-based
Category:Languages
Paintfuck++

Paintfuck++ is a derivative of Paintfuck, but now you can store data with stacks. (In Paintfuck you can't store data, you need to use the screen.)
== Instructions ==
The instructions are the instructions of Paintfuck
== New instructions ==
Instruction	Action
Any number 	Push the number written to top of the stack
. 	Pop the top item of the stack
T 	Dup the top item of the stack
, 	Pop the top item of the stack and push it at the bottom of the stack
´ 	Pop the bottom item of the stack and push it at the top of the stack
"<String>" 	Push <String> to the stack
ç 	Push the item nº(Number of the item at top of the stack) to the top of the stack (without popping)
{} 	Will create a variable with the name of
[] 	Will set to the top item of the stack (without popping)
¨¨ 	Will push the value of the variable at the top of the stack
< 	Will jump to the next > if the top two items of the stack are not equal
> 	Will jump to the correspondent < if the top two items of the stack are equal
/ 	Will jump to the next / if the top item of the stack is 0
\ 	Will jump to the correspondent \ if the top item of the stack is not 0
" 	Will jump to the next ! if the top item of the stack is bigger than -1
! 	Will jump to the correspondent " if the top item of the stack is lower than 0
== Interpreters ==
Nobody has made an interpreter as of yet.
==See also==
* Paintfuck
* Paintfuck+
Category:Languages Category:2020 Category:Stack-based Category:Unimplemented
Pairs

Pairs is an esoteric programming language created by User:Avuxo based on creating binary numbers using characters. To create a 1 use two of the same character in a sequence -- Ex: 'ff', '$$', or '55'. To create a 0 use two different characters in a sequence -- Ex: 'e#', 'rd', or 'n4'. Opcodes and operands are formed in 8-bit sequences (16 characters) and each is separated by a space Ex: 0 is HALT, 1 is store .. 10 is add , 11 is add <register(src)> <register(dest)>, etc.
Pairs is something of a reverse-golf language as it produces abnormally large programs (each binary digit requires 2 characters) This means that each bit in the program takes 16 bits to be represented
=== Hello World in Pairs===
 YYotnnizDDaBPFbK OYdqqlxxrrjKUUkq ooRGSSMLWWpWTamc JJqKSSVzzmYYVVgG rrcePPRBrrlYgecK CgZRwwKKnaddHHPa zztagglallRwtTJx MEedttjjLUAAnnlW HHBsZZDEmmdVuzxh OOZZIIwwIYhhggeo IIwIAAffVVJRBsjG wReQewBBKJEEtQvD FFTjOOlMmmKqHgsI HHBBaaJIaaIIeeRK OOStaapYuuoynVcs BBUUllGGuMLLssix BBvpjjqCffUSuLGO hwZZDjxassKKEEFF xxzCmmmcJJWiLmlB vryShhNNCxxxWWGe JJdmttXZrrbZeyve fHJhddJKzMDDccgq
===Implementations===
* Original interpreter in C
Category:Languages
Category:Output only
Palace

Palace is a functional programming language that implements some sort of Peano arithmetic. It is similar to ƎↃИAЯT, but in this language there is no addition. Instead, the successor operator is the only predefined operator. All values are non-negative integers and the only constant that can appear in the source code is zero.
== Overview ==
Source code contains one or more function definitions. Each function definition consists of function name, formal arguments and the return value. Example:
 f(x) = x
It is an identity function. It takes argument x and returns x. Successor is denoted by prefix + and it can appear either in the formal argument, or in the return expression. For example:
 g(x, 0) = x
 g(x, +y) = y
The above function g has two definitions, but both definitions define the same function g. The first definition can be applied when the second argument is zero, while the second definition can be applied when the second argument is a successor of something. It should be clear from these two examples how the syntax works.
== I/O format ==
Input is an array of non-negative integers. Output is a single non-negative integer. The first function that appears in the source code is the main function (its name is irrelevant) and its arity must match the length of the input array, because it is called when program starts.
== Examples ==
=== Successor ===
 succ(x) = +x
=== Predecessor ===
Zero stays zero.
 pred(0) = 0
 pred(+x) = x
=== Is zero ===
 isZero(0) = +0
 isZero(+x) = 0
=== Less than or equal ===
 leq(x, y) = isZero(sub(x, y))
=== Addition ===
 add(x, 0) = x
 add(x, +y) = add(+x, y)
=== Subtraction ===
\max(x-y,0)
 sub(x, 0) = x
 sub(x, +y) = sub(pred(x), y)
=== Multiplication ===
 mul(x, 0) = 0
 mul(x, +y) = add(x, mul(x, y))
=== Division ===
Rounds down. Does not halt when the divider is zero and the divident is nonzero.
 div(x, y) = div1(x, y, 0, 0)
 div1(x, y, z, 0) = div1(x, y, +z, leq(+x, mul(y, +z)))
 div1(x, y, z, +r) = pred(z)
=== Exponentiation ===
 exp(x, 0) = +0
 exp(x, +y) = mul(x, exp(x, y))
=== Root ===
Returns y-th root of x. Rounds down. Does not halt if y=0\land x\neq0.
 root(x, y) = root1(x, y, +0, leq(+x, y))
 root1(x, y, z, 0) = root1(x, y, +z, leq(+x, exp(+z, y)))
 root1(x, y, z, +r) = pred(z)
== Examples of non-primitive-recursive functions ==
All previous examples are primitive-recursive (if we ignore the fact that some of them do not halt on invalid input, like division). Here we show some total computable functions that are not primitive-recursive.
=== Ackermann function ===
 A(0, n) = +n
 A(+m, 0) = A(m, +0)
 A(+m, +n) = A(m, A(+m, n))
=== Sudan function ===
 F(0, x, y) = add(x, y)
 F(+n, x, 0) = x
 F(+n, x, +y) = F(n, F(+n, x, y), +add(F(+n, x, y), y))
=== Goodstein function ===
(TODO)
== Interpreters ==
Interpreter
Category:Languages
Category:Turing complete
Category:Implemented
Category:2020
Palette

Palette is an esoteric programming language created by User:ShanePaton. Palette uses operations based on painting and palettes.
==Instructions==
Command 	Description
# 	Creates a comment that gets ignored by the interpreter
BOTTLE 	Modifies one of the 10 paint bottles
PAINT 	Prints a string of a bottle
SPLATTERPAINT	Prints a random set of ASCII charecters
BLEND 	Adds values together and stores them in a bottle
SUBTRACT 	Subtracts values and stores them in a bottle
REDRAW 	Creates a loop that uses a number for the amount of itterations
INPUT 	Takes and stores input from the user into the inputStorage
SHOULD 	Checks if a value or input is equal to the number 1
SHOULD NOT 	Checks if a value or input is not equal to the number 1
WASH 	Ends the program and stops reading the script
==Examples==
Hello World
PAINT Hello World
WASH
OUTPUT: Hello World
Splatter Paint
SPLATTERPAINT 100
WASH
This would print 100 random ASCII Charecters
Variables
BOTTLE 1 = text Go checkout Length!
PAINT USING BOTTLE 1
WASH
OUTPUT: Go checkout Length!
Math
BLEND 47 2 1 1
SUBTRACT 53 2 1 2
PAINT USING BOTTLE 1
PAINT USING BOTTLE 2
WASH
OUTPUT: 
50
50
Truth-Machine
INPUT
SHOULD EQUALINPUT
SHOULDREDRAW 5
EQUALPAINT 1
SHOULD NOT EQUALINPUT
EQUALPAINT 0
WASH
OUTPUT:
>0
0
>1
1
1
1
1
1
Aperture Science ASCII
PAINT .,-:;//;:=,
PAINT . :H@@@MM@M#H/.,+%;,
PAINT ,/X+ +M@@M@MM%=,-%HMMM@X/,
PAINT -+@MM; $M@@MH+-,;XMMMM@MMMM@+-
PAINT ;@M@@M- XM@X;. -+XXXXXHHH@M@M#@/.
PAINT ,%MM@@MH ,@%= .---=-=:=,.
PAINT =@#@@@MX., -%HX$$%%%:;
PAINT =-./@M@M$ .;@MMMM@MM:
PAINT X@/ -$MM/ . +MM@@@M$
PAINT,@M@H: :@: . =X#@@@@-
PAINT,@@@MMX, . /H- ;@M@M=
PAINT.H@@@@M@+, %MM+..%#$.
PAINT /MMMM@MMH/. XM@MH; =;
PAINT /%+%$XHH@$= , .H@@@@MX,
PAINT .=--------. -%H.,@@@@@MX,
PAINT .%MM@@@HHHXX$$$%+- .:$MMX =M@@MM%.
PAINT =XMMM@MM@MM#H;,-+HMM@M+ /MMMX=
PAINT =%@M@M#@$-.=$@MM@@@M; %M%=
PAINT ,:+$+-,/H#MMMMMMM@= =,
PAINT =++%%%%+/:-.
WASH
OUTPUT: .,-:;//;:=,
 . :H@@@MM@M#H/.,+%;,
 ,/X+ +M@@M@MM%=,-%HMMM@X/,
 -+@MM; $M@@MH+-,;XMMMM@MMMM@+-
 ;@M@@M- XM@X;. -+XXXXXHHH@M@M#@/.
 ,%MM@@MH ,@%= .---=-=:=,.
 =@#@@@MX., -%HX$$%%%:;
 =-./@M@M$ .;@MMMM@MM:
 X@/ -$MM/ . +MM@@@M$
,@M@H: :@: . =X#@@@@-
,@@@MMX, . /H- ;@M@M=
.H@@@@M@+, %MM+..%#$.
 /MMMM@MMH/. XM@MH; =;
 /%+%$XHH@$= , .H@@@@MX,
 .=--------. -%H.,@@@@@MX,
 .%MM@@@HHHXX$$$%+- .:$MMX =M@@MM%.
 =XMMM@MM@MM#H;,-+HMM@M+ /MMMX=
 =%@M@M#@$-.=$@MM@@@M; %M%=
 ,:+$+-,/H#MMMMMMM@= =,
 =++%%%%+/:-.
"You can't rush art" - That art guy from Toy Story 2
Category:Languages
Palindrome

A palindrome is a string which reads the same forwards and backwards; that is, some string S where S = reverse(S).
Esoteric programming is primarily concerned with such strings which are programs, especially interesting ones. This generally rules out trivial palindromic programs, such as where only the first half or only the second half of the code is executed (either because the remaining half is comment or because a halt instruction is placed in the middle).
Non-trivial palindromic programs can be written in Befunge and other languages.
==See also==
* Symmetrical program
== External resources ==
* 
* Palindrome Hello World at codegolf stackexchange
Category: Program forms
PanASCIIc Programming Language

The PanASCIIc Programming Language, or PAPL, is a programming language designed by User:Hppavilion1. It aims to support all of ASCII in its semantics, such that- for example- this wiki article could be fed into it to produce some effect.
== Design philosophy ==
* Support all of ASCII (though control characters are NOPs)
* Allow text programs to be fed to it without crashing
* Maybe support some of the more common unicode in other blocks
* Do all of this in a fun way
== Syntax ==
Due to the nature of languages of this sort, PAPL pretty much needs to be a character-by-character language, similar to languages like brainfuck. Unlike brainfuck and similar languages, however, PAPL has absolutely no syntactic or semantic rules that would prevent it from executing properly- it is literally impossible for PAPL to crash. This requires some fanagling with the rules of mathematics (n/0 = ∞, for example), but it works.
== Semantics ==
PAPL is largely just a list of single-character commands, but it has a few gems.
First of all, PAPL is based off of Mascarpone in its behavior- the interpreter can be changed in order to change what commands do (this is called "modes"). This opens up a number of new available commands for PAPL, but also makes it much more difficult to choose logical meanings for commands. As such, we try to limit the number of builtin interpreters, and deem that an invalid command in the current interpreter is a NOP.
PAPL operates on a tape of deques. The deques are dynamically-typed and can hold a number of data structures and scalars: graphs, matrices, strings, other deques, floats, booleans, etc...
== Instructions ==
There are so many instructions that they need to be kept elsewhere. Also, they aren't done yet.
Category:Languages Category:Ideas Category:Deque-based Category:Works-in-Progress
Pantheon

Pantheon is a Python library designed with the notion of assigning tasks to beings, as opposed to the traditional scripting, to provide a different, game-like way of looking at code. It is heavily threaded and generally a pain in the ass to work with.
== Concept ==
Pantheon is inspired a bit by ZOMBIE. It shares the concept of creating mythical beings with assigned tasks and instructing them to do things. In a way, Pantheon elaborates on ZOMBIE by including more beings and giving you more intricate structures. Pantheon's beings include historically significant Gods, Monsters, and other sorts of powerful being.
Panu Kalliokoski

Panu Kalliokoski is the inventor of iag and Lisp2K, operates the esoteric languages mailing list, and maintains an archive of files related to esoteric programming languages, which includes The Brainfuck Archive. Panu is also the author of B5, a macro processor and toy that implements the lambda calculus -- though it is not intended to be esoteric.
==See also==
* Esolang:Community Portal for information on the mailing list
==External resources==
* esoteric.sange.fi, Panu's archive of esoteric materials
* The Brainfuck Archive, a subsection of the above
* Software work/product/experiment page
Category: People
Papadopoulos Script

Papadopoulos Script, is a semi-esoteric language, named after the Dictator Georgios Papadopoulos.The script is in Robloxian Lua, or simply Lua. It is mostly based on the 'local' commands. Most of the values are in Greeklish(Greek with Latin characters).
=== WARNING BEFORE USE ===
To execute or operate Papadopoulos Script.rbxl, you must have Roblox Studio in your device. Also, DO NOT CHANGE THE LOCALS'S NAMES. THIS MIGHT CAUSE A THOUSAND PROBLEMS IN COMPILING.
=== Commands ===
If you know how to speak Greek and English pretty fluently, it won't be so hard for you to work with it. The basic commands of Papadopoulos Script are the same as Lua. Here are the changes: The game is now called 'gaem'. The Workspace is now called 'Junta'. The Baseplate is called 'Athens'. Transparency is called 'Pattakos', who is another Greek dictator, partner of Papadopoulos. Lighting is 'Lamtpis', which is flashlight in Katharevousa. ServerStorage is 'Eptaetia', which means 7 years(The time of the Greek Junta). MaterialService is 'Venizelos', respectfully named after the Greek leader. Players are called 'Stratos', which means Army. StarterGui is 'Eikona', which means Picture. Terrain is 'Edafos'. SpawnLocation is 'Vasi' which means base. Teams are now 'Armies'. Chat is 'Koinwnia', which is society in Greek. BubbleChatConfiguration is 'Milaw', which is "I speak" in Greek. SoundService is 'Hxos'. Camera is 'Photographia'. ServerScriptService is 'Syndesmos'. Lastly, Print is 'Diaggelma'.
ParScript

ParScript is an esoteric programming language designed for the purpose of code golf. An interpreter is in the process of being made.
== Description ==
ParScript is a simple stack-based language that enables writing of concise (and unreadable) code. It has a wide selection of library functions for manipulation of data. A notable feature is that arithmetic operations work on scalars as well as lists (like in APL).
== Syntax ==
Here is a simplified (BNF-like) syntax.
 Prog ::= Exp*
 Exp ::= Lit | Id | Sp
 Lit ::= Num | Str | Blk | Sym
 Str ::= "(" .* ")"
 with match parens
 Sym ::= "'" .
 Blk ::= "[" Prog "]"
 Num ::= Digit+ ["." Digit+] ["e" ["+"|"-"] Digit+]
 Id ::= Alpha+ ["+"|"*"|"'"]
 Sp ::= regex \s+
 Digit ::= regex \d
 Alpha ::= regex [a-zA-Z]
== Example programs ==
A few example programs are given below.
===Hello world program===
 (Hello, world!
 )p
 (or, if you wish, you can use the library function)`
 H
===nCr program===
(usage: N1 N2 ncr; assume N1,N2 >0)
 (The ncr function is given as the number of ways to select
 r objects from a set of n unique objects if order is not
 important. It is given as ncr(n,r)=n!/r!(n-r)! where ! is
 the factorial function.)`
 (The factorial function is not defined in the standard
 library, though it is easily defined as [i f*].)`
 (ncr1)[\\-i@i@i@&/f*]d
 (ncr2)[\i@\~-i~i&/f*]d
==Library functions==
A list of library functions is given below. This is by no means an exhaustive list.
===Stack manipulation===
 ` pop ( a -- ) ~ swap ( a b -- b a )
 $ dup ( a -- a a ) \ over ( a b -- a b a )
 @ rot ( a b c -- c a b ) : nil ( -- : )
===List manipulation===
 . cons ( y x -- x:y) , uncons ( x:y -- y x )
 & append ( l1 l2 -- l3 ) # index ( l n -- x )
 { begin ( -- { ) } end ( { ... -- l )
 S sort ( l -- l ) J jumble ( l -- l )
 l length ( l -- n )
===Control flow===
 ? ifthen ( c f1 f2 -- ) I if ( c f1 -- )
 w while ( c f -- ) ! call/eval ( x -- ??? )
===Higher-order functions===
 m map ( l f -- l' ) g grep ( l f -- l' )
 f fold ( l x f -- x' ) A all ( l f -- b )
 O any ( l f -- b )
===Arithmetic===
Arithmetic functions are versatile, they either work on pairs of numbers (the usual interpretation), on one number and one list (a map()) or two lists (a zipWith()).
For example:
 1 2 * ==> 2
 1 {2 3 4}* ==> {2 3 4}
 {1 2 3} 4* ==> {4 8 12}
 {1 2 3} {4 5 6}* ==> {4 10 18}
 {1 2} {4 5 6}* ==> {4 10} (truncated due to lack of elements)
The arithmetic functions are:
 + add ( a b -- a+b ) - subtract ( a b -- a-b )
 * multiply ( a b -- a*b ) / divide ( a b -- a/b )
 ^ power ( a b -- a^b ) % mod ( a b -- a%b )
 _ negate ( a -- -a )
==Turing-completeness==
The author suspects that this language can be Turing-complete by reduction from Brainfuck, but has not yet come up with a suitable reduction.
Category:Unimplemented
Category:Stack-based
Category:Unknown computational class
Category:2012
Category:Languages
Paradox

Paradox is a language concept by User:Maxsteele2 which is like a cross between BASIC and TwoDucks.
==Description==
Paradox is different to the (possibly) average programming language by requiring some lines not to function.
==Programs==
===Hello, World!===
 10 set20:"Hello World"
 20 This line is skipped
 30 print20
 40 terminate
This program results in;
 Hello World
Line 20 is skipped, because the number 20 was given the value of "Hello World". If the line was written as such;
 Hello World This line is not skipped.
...then the ine would not be skipped, and as a result, this;
 Error: "This" is not a command
 Error: "line is not a command" is not an object.
 Hello World
===Quine===
Quines are easier to do in Paradox than other languages.
 10 set30:10thru40
 20 print30
 30 This line will not run FIRE MAH LAZER BLAAA
 40 terminate
Notice that in line 10, there were no quotation marks. This is important, as if there were quotation marks, the result would have been much less impressive.
===Why?===
This feature is useful for getting information from databases. For instance:
 10 goto 60
 20 Space is pressed. 
 30 terminate
 40 Space is not pressed.
 50 terminate
 60 if input="space"
 70 goto 20
 80 goto 40
===Input Terminator===
This line will terminate if input is detected from the spacebar.
 10 if input="space" goto 30
 20 goto 10
 30 terminate
==?==
I forgot what this one was for...
ParamNO

ParamNO is an esoteric programming language invented by codingMASTER398 in 2021.
It is created to be similar to other programming languages but with shuffled parameters.
It is unknown whether it is Turing complete.
== The trick ==
The base of ParamNO would be a fairly normal language if not for the param shuffling.
 PRINT
 -NUMBER 1 
 -NUMBER 2 
 -NUMBER 3 
Can output
 1
 3
 2
Or any other combination of 1, 2 and 3, because the parameters (starting with dashes) are randomised in their order of execution
== Example code ==
 // This is an example of my ParamNO esolang
 // Comments can be made with double lines like in JavaScript
 // But you can't append a comment to a line of actual code, so make sure you are on a new line.
 
 
 // This function called "GOO" Should never run
 FUNC goo
 PRINT
 -TEXT Huh? This isn't supposed to run
 
 // Any line starting with "FUNC" will become a new function. It must have a name.
 
 // Say you wanted to print something, you would have the PRINT function, then following that, parameters starting with a -
 // Most parameters have to start with something like "TEXT" or "VAR" depending on what it's referring to.
 // Parameters are jumbled though and scrambled, as that is the base concept of this esolang
 
 
 FUNC MAIN
 
 // The MAIN function is always called first.
 
 
 // Here we set the variable GOO to GOO and print it.
 
 SET
 -TEXT GOO
 -TEXT GOO
 
 PRINT
 -VAR GOO
 
 IF
 -TEXT GOO
 -TEXT GOO
 -TEXT GOO
 
 PRINT
 -TEXT "GOO" is not "GOO" for some reason
 
 // Here we use a workaround for the IF statement
 // Because all parameters are jumbled, it's better if all the parameters are the same. You can't do much that way but it makes sure that it runs 100% of the time.
 
 //IF the text "GOO" is equal to "GOO" then we go to the function called "TEXT GOO". When you go to a function, it cancels all the other lines after it.
 
 FUNC TEXT GOO
 
 PRINT
 -TEXT Yes, "GOO" is in fact "GOO"
== Bottles of beer on the wall ==
 // This program is the fastest known way to write the beer on the wall program. It doesn't use any double parameters and will always run perfectly.
 FUNC MAIN
 INPUTNUM
 -TEXT bottles
 GO
 -DOWN
 FUNC DOWN
 PRINT
 ADDNEXTPRINT
 -VAR bottles
 ADDNEXTPRINT
 -TEXT bottles of beer on the wall,
 ADDNEXTPRINT
 -VAR bottles
 PRINT
 -TEXT bottles of beer!
 MINUSONE
 -bottles
 ADDNEXTPRINT
 -TEXT Take one down, pass it around
 ADDNEXTPRINT
 -VAR bottles
 PRINT
 -TEXT bottles of beer on the wall.
 ZEROSTOP
 -VAR bottles
 GO
 -DOWN
 FUNC STOPOVERRIDE
 PRINT
 PRINT
 -TEXT No more bottles of beer on the wall, no more bottles of beer.
 PRINT
 -TEXT There's nothing else to fall, because there's no more bottles of beer on the wall.
== Commands and installation ==
https://github.com/codingMASTER398/ParamNO
Category:Languages Category:Implemented Category:Unknown computational class
Pararedox

== the short intro ==
Pararedox is an text-based esolang that is focused on Redefining and Redoing
== syntax ==
the syntax will always be two or three letter commands (case sensitive) either with arguments or variants (variant ids also have a maximum of 3 letters/symbols)
Here are some examples and definitions (? Is a placeholder symbol and probably won’t be used in any future commands or syntax):
 ??.? Is the variant of ?? corresponding to ?.
 ??() command example with inputs
 ?? command example
instead of using stacks or variables, it uses 3 arrays (alpha (α), beta (β) and gamma (γ))
this also supports succession, the opposite of succession and loops, make the hyperoperations yourself.
the symbol ! is this language’s equivalent of javascript’s ;
Yes, basic normal comparison is present within this esolang.
== commands ==
* Suc(n:numb) | inp, out | output: n+1
** Suc.O(n:numb) | inp, out | output: n-1
* LP(until:bool, do:PARRD script) | inp, do | basic until loop
* Fnc(name:string (min: 3L, max: 4L), argument1:string(max:3L), argument2:string(max:3L), do:PARRD script) | inp, do | basic function definer
* Var(name:string(maximum: 3L), Val:any) | inp | defines/redefines a variable
* Red(letter1:string(1L), letter2:string(2L)) | inp | rewrites the command above, replacing the first letter1 with letter2, if the command above is another Red, then look above
** Red.Var(VariantId:String(1L)) | inp | rewrites the command above, setting the variant to VariantId, if the variant already is VariantId, then remove the variant, if the command above is another Red, then look above
** Red.o | none | redos the whole script
* Skp(if:Bool) | input | skips the command below if the bool is true
* Out(output:any) | inp | is an output for a function, if isn’t in a function, print.
Category:Languages Category:2024