Deadfish/Implementations (M-Z)

__TOC__
Deadfish has been implemented in lots of different languages, both practical and esoteric. This page lists some of them.
== Metabox ==
┌────────────────────────────────────────────────────────────────────────────┐
│┌──────────────────────────────────────────────────────────────────────────┐│
││┌─────────────────────────────────┐ ││
│││┌───────────────────────────────┐│ ││
││││┌─────────────────────────────┐││ ││
│││││┌─────────────┐ set variable │││ ││
││││││start program│ "a" to 0 │││ ││
│││││└─────────────┘ │││ ││
││││└─────────────────────────────┘││ ││
││││ set variable "b" to 0 ││ ││
│││└───────────────────────────────┘│ ││
│││ print ">> " & input │ ││
││└─────────────────────────────────┘ ││
││ ││
││ ││
││ loop (length of input) times ││
││┌────────────────────────────────────────────────────────────────────────┐││
│││if character (variable │││
│││ "a") of input = o │││
│││ ┌──────────────────┐ │││
│││ │print variable "b"│ │││
│││ └──────────────────┘ │││
│││┌──────────────────────────────────────────────────────────────────────┐│││
││││┌────────────────────────────────────────────────────┐ ││││
│││││ if character (variable "a") of input = s │ ││││
│││││┌───────────────────────────────────────────────┐ │ ││││
││││││set variable "b" to variable "b" * variable "b"│ │ ││││ 
│││││└───────────────────────────────────────────────┘ │ ││││
│││││┌──────────────────────────────────────────────────┐│ ││││
││││││ if variable "b" = -1 ││ if variable "b"││││
││││││┌─────────────────────┐ ││ = 256 ││││
│││││││set variable "b" to 0│ ││ ┌────────────┐ ││││
││││││└─────────────────────┘ ││ │set variable│ ││││
││││││┌────────────────────────────────────────────────┐││ │ "b" to 0 │ ││││
│││││││┌──────────────────────┐ │││ └────────────┘ ││││
││││││││if character (variable│ if character (variable │││ ││││
││││││││ "a") of input = i │ "a") of input = d │││ ││││
││││││││ ┌───────────────┐ │ ┌───────────────┐ │││ ││││
││││││││ │set variable │ │ │set variable │ │││ ││││
││││││││ │"b" to variable│ │ │"b" to variable│ │││ ││││
││││││││ │"b" + 1 │ │ │"b" - 1 │ │││ ││││
││││││││ └───────────────┘ │ └───────────────┘ │││ ││││
│││││││└──────────────────────┘ │││ ││││
││││││└────────────────────────────────────────────────┘││ ││││
│││││└──────────────────────────────────────────────────┘│ ││││
││││└────────────────────────────────────────────────────┘ ││││
│││└──────────────────────────────────────────────────────────────────────┘│││
││└────────────────────────────────────────────────────────────────────────┘││
│└──────────────────────────────────────────────────────────────────────────┘│
│ end program │
└────────────────────────────────────────────────────────────────────────────┘
== METAFONT ==
This is limited range due to limit of numbers in METAFONT.
 scrollmode;
 warningcheck:=0;
 inner end;
 Q:=0;
 def Z = if(Q<0)or(Q=256):Q:=0;fi enddef;
 def i = Q:=Q+1;Z; enddef;
 def d = Q:=Q-1;Z; enddef;
 def s = Q:=Q*Q;Z; enddef;
 def o = message decimal Q; enddef;
 def h = ;end; enddef;
== Minecraft commands ==
 # works in Minecraft 1.19.4-pre1 (and later, hopefully)
 # this file should be located at data/deadfish/functions/deadfish.mcfunction in a data pack
 # (for example, see data pack on GitHub: https://github.com/Arctenik/mc-data-packs/tree/main/interpreters/Deadfish)
 # to use the interpreter, run a command like this to initialize the program in the "code" tag of the deadfish storage:
 # /data modify storage deadfish code set value "iiisiiisdddddddo"
 # and then run this function:
 # /function deadfish:deadfish
 #####################################
 
 # make sure the scoreboard objective exists
 scoreboard objectives add deadfish dummy
 # if a program is stored in the "code" tag, start running that program
 # move it the the "code_internal" tag and set the accumulator to 0
 execute if data storage deadfish code run data modify storage deadfish code_internal set from storage deadfish code
 execute if data storage deadfish code run scoreboard players set $accumulator deadfish 0
 data remove storage deadfish code
 # if running a program, move its first character to the "command" tag
 execute if data storage deadfish code_internal unless data storage deadfish {code_internal:""} run data modify storage deadfish command set string storage deadfish code_internal 0 1
 execute if data storage deadfish code_internal unless data storage deadfish {code_internal:""} run data modify storage deadfish code_internal set string storage deadfish code_internal 1
 # evaluate the command, if it exists and is a valid command
 execute if data storage deadfish {command:"i"} run scoreboard players add $accumulator deadfish 1
 execute if data storage deadfish {command:"d"} run scoreboard players remove $accumulator deadfish 1
 execute if data storage deadfish {command:"s"} run scoreboard players operation $accumulator deadfish *= $accumulator deadfish
 execute if data storage deadfish {command:"o"} run tellraw @a {"score":{"name":"$accumulator","objective":"deadfish"}}
 data remove storage deadfish command
 # zero the accumulator as appropriate
 execute if score $accumulator deadfish matches -1 run scoreboard players set $accumulator deadfish 0
 execute if score $accumulator deadfish matches 256 run scoreboard players set $accumulator deadfish 0
 # recurse if there's a non-empty program being run
 execute if data storage deadfish code_internal unless data storage deadfish {code_internal:""} run function deadfish:deadfish
== MineFriff ==
 ` [MineFriff Deadfish Interpreter]
 0,` [The first item in the stack will always be the accumulator]
 >Ca*62,a*62, oo i` [Output the interpreter prompt and then accept input]
 r.rI, Cffc, $` [Switch the stack around, adding a star on]
 v
 ^>r:Cffc,=?#v!~ 
 >r:I8*8*4,= ?#v.*0,` [Check the 256 requirement]
 v >:I1-2,=?#~.*0,~ [Check the -1 requirement]
 ^ >r:Cf*7,=?#v!rI1,+~ [i(ncrement the accumulator)]
 ^ >:Ca*a,=?#v!rI1,-1~ [d(ecrement the accumulator)]
 ^ >:Ca*b1,=?#v!r:oCa,o~ [o(utput the accumulator)]
 ^ >:Ca*b5,=?#v!r:*~ [s(quare the accumulator)]
 ;
== minigolf ==
0i,nWT*+1,;,nB=,:_n0=,T+_n5=,1+_nF=,:*__::V=sT=+,0*__,_
== MIPS Assembly ==
This code only accepts one lowercase letter at a time as a valid Deadfish command.
.data
readable: .asciiz ">> "
character: .space 2 # 1 bit + \0
new_line: .asciiz "\n"
.text
li $t0, 0 # character
li $t1, 0 # numeral
start_deadfish_loop:
la $a0, readable
li $v0, 4
syscall
la $a0, character
li $a1, 2
li $v0, 8
syscall
lbu $t0, ($a0)
bne $t0, 100, not_d
addi $t1, $t1, -1
j end_chars
not_d:
bne $t0, 105, not_i
addi $t1, $t1, 1
j end_chars
not_i:
bne $t0, 111, not_o
la $a0, new_line
li $v0, 4
syscall
move $a0, $t1
li $v0, 1
syscall
j end_chars
not_o:
bne $t0, 115, end_chars # s
mul $t1, $t1, $t1
end_chars:
la $a0, new_line
li $v0, 4
syscall
blt $t1, $zero, set_to_zero
beq $t1, 256, set_to_zero
end_number_checking:
j start_deadfish_loop
set_to_zero:
li $t1, 0
j end_number_checking
== Mirah ==
 no=0
 while true do
 if no==-1 or no==256 then
 no=0
 end
 print ">> "
 the_cmd = System.console.readLine()
 if the_cmd.equals("d") then
 no=no-1
 elsif the_cmd.equals("i") then
 no=no+1
 elsif the_cmd.equals("s") then
 no=no*no
 end
 if the_cmd.equals("o") then
 puts "#{no}"
 end
 end
== MIX (Knuth) ==
Assembly code (the MIXPC assembler; not quite the same as MIXAL):
* DEADFISH ON MIX
* PUBLIC DOMAIN
 * CHANGE TO 64 FOR BINARY COMPUTERS
 BASE 100
 START
 * STORE CURRENT VALUE IN ACCUMULATOR
RESET ENTA 0
 * DISPLAY PROMPT AND REQUEST INPUT
MAIN CMPA =256=
 JE RESET
 OUT PROMPT(19)
 IN INBUF(19)
 JBUS *(19)
 * DISPATCH BY INPUT
 LD1 INBUF(1:1)
 DEC1 'D'
 J1Z OP_D
 DEC1 'I'-'D'
 J1Z OP_I
 DEC1 'O'-'I'
 J1Z OP_O
 DEC1 'S'-'O'
 J1Z OP_S
 JMP MAIN
 * DECREMENT
OP_D JAZ MAIN
 DECA 1
 JMP MAIN
 * INCREMENT
OP_I INCA 1
 JMP MAIN
 * SQUARE
OP_S STA 0
 MUL 0
 SLAX 5
 JMP MAIN
 * OUTPUT
OP_O STA 0
 CHAR
1H CMPA ='0'(1:1)=(1:1)
 JNE 1F
 SLAX 1
 JMP 1B
1H JANZ 1F
 LDA ='0'(1:1),0(2:5)=
1H STA INBUF
 STX INBUF+1
 OUT INBUF(19)
 LDA 0
 JMP MAIN
PROMPT TEXT ">>"
 FILL PROMPT+14
INBUF FILL *+14
 END
Deck (for use with decimal versions of MIX) (note that each card has a space in the first character position):
 N O6 A O4 H N ENX E K BU I OALH A. PAEN D LB E AEU ABG G 9 
 5 7 5 2487 5 5 53971 25 193671 25 9 97 665 1417 695 1417 755 141 
 5171165 5567 885 19377 555 19347 45 1497 55 1497 75 1497 65 149 
 647 715 1417 515 14 7 515 397 515 397 5 5 37 515 397 5 1 5 
 657 515 397 15 1487 15 487 5 5247 55 2 67 5 52471175 956 
 787 815 8397 775 3971185 5 871 35 5317 5 5 821515 7 5 
 797 15 2 67 835 44 71 25 52471 25 19377 515 397 5 7 5 
 927 5 7 5 7 5 7 5 7 5 7 5 7 5 
 937 5 7 5 7 5 7 5 7 5 7 5 7 5 
 1 67 5 7 5 7 5 7 5 7 5 7 5 2560 5 
 1 77 5 7 5 7 5 7 5 7 5 0 5 
 147 5 5 39 
This is the version of the deck for binary computers:
 N O6 A O4 H N ENX E K BU I OALH A. PAEN D LB E AEU ABG G 9 
 5 7 5 1767 136 75597 2623994 7 262392737 178 16 97 18588 417 1916 9 5 
 517 3 9 9 8 7 235699257 1491917 7 15486897 181 8337 13351217 1072977 
 647 181123297 138694487 138693837 138693837 5 3237 138693837 5 69 
 657 138693837 7622567 7621927 5 3447 181 8547 5 3447 3 17148 
 787 217342157 2 6851277 3 43332 7 275 11837 5 32878695 736 7 5 
 797 7622787 212582487 26239 327 262399417 138693837 5 7 5 
 927 5 7 5 7 5 7 5 7 5 7 5 7 5 
 937 5 7 5 7 5 7 5 7 5 7 5 7 5 
 1 67 5 7 5 7 5 7 5 7 5 7 5 25675 381648 
 1 77 5 7 5 7 5 7 5 7 5 75 381648 
 147 136 7239 
== MMIX ==
v	GREG 0
	LOC Data_Segment
buf	OCTA 0,0,0,0
buf2	BYTE 0,10,0
arg	OCTA buf,1
	GREG buf
	LOC #100
	BYTE ">> ",0
G256	GREG #100
	% Prompt for and read input
Main	LDA $255,#100
	TRAP 0,Fputs,1
	LDA $255,arg
	TRAP 0,Fread,0
	% Set to zero if -1 or 256
	ZSP v,v,v
	CMP $0,v,G256
	CSZ v,$0,0
	% Check what command has been specified
	LDBU $0,buf
	SUB $0,$0,10
	BZ $0,Main
	SUB $0,$0,'d'-10
	PBNZ $0,1F
	% Decrement
	SUB v,v,1
	PBZ $0,2F
1H	SUB $0,$0,'i'-'d'
	PBNZ $0,1F
	% Increment
	ADD v,v,1
	PBZ $0,2F
1H	SUB $0,$0,'o'-'i'
	PBNZ $0,1F
	% Output
	LDA $255,buf2
	DIV $1,v,10
3H	GET $0,rR
	ADDU $0,$0,'0'
	STBU $0,$255
	BZ $1,3F
	SUBU $255,$255,1
	DIV $1,$1,10
	PBNZ $255,3B
3H	TRAP 0,Fputs,1
	PBZ $1,2F
1H	SUB $0,$0,'s'-'o'
	PBNZ $0,1F
	% Square
	MUL v,v,v
	PBZ $0,2F
1H	ADD $0,$0,'s'-'h'
	BNZ $0,2F
	% Halt
	TRAP 0
	% Skip the rest of the input line
2H	LDA $255,arg
	TRAP 0,Fread,0
	LDBU $0,buf
	SUB $0,$0,10
	PBNZ $0,2B
	PBZ $0,Main
== MNNBFSL ==
Currently, all instructions must be on a single line.
[ _
<[<[-"]++++++">>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<[<_[->+<"][]>"+_
]_+">++++]_checked if acc = 1 under 0>
<"[<[-"]++++"">>>[<[-"]<<-[>"<-"][]<-[>>>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<<-"][][->+<"][][->-<"]_
[<[-"]++++++">>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<[<_[->+<"][]>[]_
][-"]">++++] checked if acc = 256 >_
,_+[-"][][<[-"]++++++++++">>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<[->-<"]
[++++++++++">>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<<[->+<"][]>"_
]<->++">] checked if command = d _
_
-----_
[<[-"][++++++++++">>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<<[->+<"][]>"_
]<+>++">] checked if command = i _
_
------_
[<[-"][++++++++++">>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<<[->+<"][]>"_
]<".>++">] checked if command = o_
_
----_
[<[-"][++++++++++">>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<<[->+<"][]>"_
]<">>[<[-"]<<-[>"<-"][]>[[-<<<+>>>"][]"][]<>++">] checked if command = ^2
== Nim ==
 var a = 0
 while true:
 if a == -1 or a == 256:
 a = 0
 write(stdout, ">> ")
 case readLine(stdin)
 of "d":
 a -= 1
 of "i":
 a += 1
 of "o":
 echo(a)
 of "s":
 a = a * a
== Nqubl ==
Implementation by User:David.werecat, interprets only one instruction per line.
 #
 " >>"E
 GT3S3T0T0T0T0S0
 #G~10~=KX}{#
 "i"=!KX}S2MS0#
 "d"=!KX}S2DS0#
 "s"=!KX}S2T3S4~0~]#S3T0S0~0~=KX}S3DS2T0S4T0S0+T4{#S4T2S0#
 "o"=!KX}S2NS0~10~P#
 S2T0T0S0
 ~256~=!KX}S2~0~S0#
 ~-1~=!KX}S2~0~S0#
 [[[[[[[[{
== Numbers ==
 20 0 20 100 35 11 24 40 42 17 20 1 21 11 42 44 20 5 25 11 24 40 42 31 20 1 21 10 42 44 20 6 25 11 24 40 42 42 30 42 44 26 12 42 3
== OASYS (OAC) ==
class player {}
property int dummy
int value
method check {
 if value == -1 or value == 256 value = 0
}
method increment verbs {{i} {x}} {
 value = value + 1
 this check
}
method decrement verbs {{d}} {
 value = value - 1
 this check
}
method square verbs {{s} {k}} {
 value = value * value
 this check
}
method output verbs {{o} {c}} {
 print value
 print "\n"
}
method init {
 player = create player
}
== OASYS Assembler ==
[&]%@*>
['I'X]%#%#<UP>+&CHK
['D]%#%#<DN>+&CHK
['S'K]%#%#<%#<MUL>+&CHK
['O'C]%#<PI CR
[&CHK]%#<-1EQ/%#<256EQ/ RP:%#0>
== Obfuscated C ==
Implementation by User:David.werecat, interprets only one instruction per line.
 #include <stdio.h>
 #define A case
 #define B(x,y) A x:;y;R;
 #define C "%c"
 #define D(x) O(S,x);S(x)
 #define E(x) O(while,x){
 #define F(x,y,z) x(y,z);
 #define G getchar()
 #define H char
 #define I "%i"
 #define J main
 #define K(x,y,z) x y z
 #define L printf
 #define M }}}}
 #define N "\n"
 #define O(x,y) x(y)
 #define P(x) F(L,I N,x)
 #define Q(x,y) K(x,=,y)
 #define R break
 #define S(x) F(L,C,x)
 #define T(x) O(if,x){
 #define U(x) O(switch,x){
 #define V void
 #define W int
 #define X(x,y) x y
 #define Y(x) K(x,!=,10)
 #define Z(x) Q(x,0);
 V J(){W Z(a)H m;E(1)D(K((K(30,+,1)),<<,1))F(Q,m,G)U(m)B(K(3,*,K(5,*,7)),X(a,++))B(K((K(5,*,5)),<<,2),X(a,--))B(111,P(a))B(K(5,*,23),K(a,*=,K(a,^,0)))}T(K((K(a,<,0)),|,(K(a,==,(K(1,<<,8))))))Z(a)}T(Y(m))E(Y(G))M
== OCaml ==
 let rec loop (x', s) : (int * string) -> unit =
 print_string (s ^ ">> ");
 let line = read_line () in
 let c = if String.length line > 0 then line.[0] else '?' in
 let x = match x' with (-1 | 256) -> 0 | _ -> x' in
 loop (match c with
 | 'i' -> (x+1, "")
 | 'd' -> (x-1, "")
 | 'o' -> (x, string_of_int x ^ "\n")
 | 's' -> (x*x, "")
 | _ -> (x, "\n")
 )
 let _ = loop (0, "")
== OLNMLN ==
 j0006A?p0000#p0000ij0006Fcˇi=GIGcˇd=HDHcˇs=JSJcˇo=KOKp0000=LALˇ{^rj0007Zr@p-001=QWQ@p0256=EREj0006YFI.ZD,ZS@@*#ZO&ZW.YRp0000#Y
== ONE WAY ==
 second
 push 0
 push true
 push type
 push true
 while
 push ">> 
 print
 input
 split
 dupe
 push type
 equal
 not
 while
 dupe
 push "h
 equal
 if
 drop
 push true
 while
 push type
 equal
 not
 push false
 else
 dupe
 push "d
 equal
 if
 second
 dupe
 push 0
 equal
 not
 if
 dupe
 push 257
 equal
 if
 drop
 push 0
 else
 push -1
 add
 else
 dupe
 push "i
 equal
 if
 second
 dupe
 push 255
 equal
 if
 drop
 push 0
 else
 push 1
 add
 else
 dupe
 push "o
 equal
 if
 second
 dupe
 repr
 print
 push "\n
 print
 else
 second
 dupe
 push 16
 equal
 if
 drop
 push 0
 else
 dupe
 multiply
 drop
 dupe
 push type
 equal
 not
 dupe
 push type
 equal
== Odin ==
Run with command line argument i.e. deadfish.exe "dddio"
package bf
import "core:fmt"
import "core:c/libc"
import "core:os"
num : i32
bound :: proc(n:i32)->i32 {
 if (n==-1 || n==256)
 {return 0}
 else 
 {return n}
}
main :: proc() {
 
 // input := "iioiho"
 input := os.args[1]
 fmt.println("input " , input)
 num = 0
 size_input := len(input)
 loop: for char in input {
 switch char {
 case 'd':
 num -=1
 num = bound(num)
 case 'i':
 num +=1
 num = bound(num)
 case 'o':
 fmt.println(num)
 case 's':
 num *=num
 num = bound(num)
 case 'h':
 break loop
 }
 }
 //
}
== OOLANG ==
In this interpreter added instruction "h", to end execution.
x.0.set;
a.label;
a.Input code:..in;
x>256.31.5.ifa;
x<0.31.7.ifa;
a==i.9.12.ifa;
x.inc;
a.goto;
a==d.14.17.ifa;
x.dec;
a.goto;
a==s.19.22.ifa;
x.x.mul;
a.goto;
a==o.24.27.ifa;
x.get;
a.goto;
a==h.29.29.ifa;
.halt;
x.0.set;
a.goto;
== Pair ==
Set output_as_string to true if you want unicode output instead of integer list.
 output_as_string = false
 main src = format_output | reverse | index 1 | exec_state (map_m run src) [int_0, ""]
 
 format_output = ite output_as_string (map | dot int_val abs) | show_list show_int
 run x = index (elem_index' x "idso") inst_funcs
 inst_funcs = [increment, decrement, square, output]
 normalize n = ite (elem n [int_neg_1, mk_int 0 256]) int_0 n
 modify_val f = modify' 0 | dot normalize f
 increment = modify_val inc_int
 decrement = modify_val dec_int
 square = modify_val | pow_int' | mk_int 0 2
 output = bind (get' 0) | dot (modify' 1) cons
== Parse this sic ==
Prompts the user to input a one-line idso Deadfish program. Outputs are separated by spaces (" ").
 -((dominate&&(*)))/(**)(&)|/(&*)
 |&((ditto&(times&G&G&)(*)))/(**)(&)
 /*&(((p&(dominate&p&1&)&)p&))((ditto&H&(*)))/=
 /*((ditto&(c&(*)I&)iI&))/(**)((ameliorate&*1&))|
 /*((ditto&(c&(*)D&)dD&))/(**)((dominate&*1&))_|&|
 /*((ditto&(c&(*)S&)sS&))/(**)((times&(*)*))_|&|
 /*((ditto&(c&(*)O&)oO&))/(**)(walking&(651&&)&)*_|&|
 /(**)_|&(2&)+((*))&/|/( &)/**( &)=/**(0 &)=
 |((dominate&(*)(times&(spaces&(*)A&)A&)))/|
 /*( &0& &)|((dominate&(*)1&))/*( &* &)_|&|/**( &1& &)
 |&((spaces&*A&))_+(((()&%&deeccus)))(&1&&p)&H%
== Pascal ==
 PROGRAM deadfish (INPUT, OUTPUT);
 VAR
 cmd: CHAR;
 acc: INTEGER;
 BEGIN
 acc := 0;
 REPEAT
 WRITE(‘>>’);
 READLN(cmd);
 CASE cmd OF
 ‘i’ : acc := acc+1;
 ‘d’ : acc := acc-1;
 ‘s’ : acc := SQR(acc);
 ‘o’ : WRITELN(acc);
 END;
 IF acc<0 THEN acc := 0;
 IF acc=256 THEN acc := 0;
 UNTIL cmd=‘h’;
 END.
==Path==
 ┐ ┌$$$┐
 ├256JJ=1^┐ ├~:001jj±-&-%v$$$$:501jj±-&-%v$$$$:111jj±-&-%v$$$$:115JJ±-&-%v┐
 │ ┌─┘ 0 ┌-$v1$$$$$┘ │ │ ││
 │ └$$$$┘ │ │ │ │ ││
 └──────────────┤ └─$─$─0─┬────────+$$$$$┘ │ ││
 └──────────┤ ┌─────────p.:$$$$$┘ ││
 └────────────┤ ┌──────────×:$$$$$┘│
 └───────────────┤ │
 └─────────────$$$$$┘
== Perl ==
#!/usr/bin/perl -w
my $acc=0;
while (1) {
 print ">> ";
 $_ = <>;
 if ($acc==-1 or $acc==256) { $acc=0; }
 if (/^i$/) { $acc++; }
 elsif (/^d$/) { $acc--; }
 elsif (/^o$/) { print $acc, "\n"; }
 elsif (/^s$/) { $acc*=$acc; }
 else { print "\n"; }
}
== Pike ==
A terrible oversight (that of not having a Pike Deadfish) has now been corrected. ;)
// Deadfish in Pike (Pike v8.0 release 702), version 1 -- dnm 2023-11-08
int a = 0;
int main() {
 while(1) {
 write(">> ");
 string in = Stdio.stdin->gets();
 array(string) chars = in/"";
 foreach(chars ;; string char) {
 switch(char) {
 case "i": a = a + 1; break;
 case "d": a = a - 1; break;
 case "s": a = a * a; break;
 case "o": write(a + "\n"); break;
 }
 if((a == 256) || (a < 0)) { a = 0; }
 }
 }
}
== Plurple ==
xkcd only.
ooc:Used targets as input.
create ranged number acc.
fight:@targets.
 attack (acc<0 or acc==256);
 hit:
 acc is 0.
 done.
 menu target.
 option:"x".
 acc up.
 option:"d".
 acc down.
 option:"k".
 acc is (acc ^ 2).
 option:"c".
 say acc.
 done.
 grind yes.
 ooc:this is valid.
done.
== Postrado ==
 And now it's time to pack everything up
 Thanks for 0 ac
 Oh. And don't forget the. BOOKFISH
 Three, two, one 1
 I remember some memories with it
 £
 [Thanks for I think the bus is titled in
 Why? Because in is i
 Everybody down the stairs
 ac
 [ac + 1]
 £
 Why? Because in is d
 Everybody down the stairs
 ac
 [ac - 1]
 £
 Why? Because in is s
 Everybody down the stairs
 ac
 [ac * ac]
 £
 Why? Because in is o
 Oh. And don't forget the. ac]
 £
 I'M QUIT
== PostScript ==
 % Run with: gs -q -dNODISPLAY deadfish.ps
 /C <<
 (i) {1 add}
 (d) {1 sub}
 (h) {quit}
 (o) {dup =}
 (s) {dup mul}
 >> def
 0 {
 (>> ) print flush
 C (%lineedit) (r) file 1 string readstring pop get exec
 dup 256 eq {pop 0} if
 dup 0 lt {pop 0} if
 } loop
== PowerShell ==
 $instructions = Read-Host "Commands"
 $accumulator = 0
 $outputaschar = $true
 $instruction = 0
 while ($instruction -le $instructions.Length)
 {
 if ($instructions[$instruction] -eq "i") {$accumulator = ($accumulator + 1) % 255}
 if ($instructions[$instruction] -eq "d") {$accumulator = ($accumulator - 1) % 255}
 if ($instructions[$instruction] -eq "s") {$accumulator = ($accumulator * $accumulator) % 255}
 if ($instructions[$instruction] -eq "o") {
 if ($outputaschar -eq $true) {
 [char]$characcumulator = [char]$accumulator
 Write-Host -NoNewline -Object $characcumulator
 } else {
 Write-Host $accumulator
 }
 }
 $instruction = $instruction + 1
 }
PowerShell deadfish interpreter, made by Yurkapotam
== Prolog ==
 deadfish(Prog, I) :-
 when((ground(Prog);ground(ProgList)), atom_chars(Prog, ProgList)),
 when((ground(I);ground(Digits)), number_chars(I, [Digit | Digits])),
 phrase(deadfish(ProgList, 0), [Digit | Digits]).
 
 deadfish([], _) -->
 [].
 deadfish([o | Prog], I) -->
 {
 I >= 0,
 number_chars(I, Digits)
 },
 Digits,
 deadfish(Prog, I).
 deadfish([i | Prog], I) -->
 {
 I1 is I + 1,
 deadfish_(I1, I2)
 },
 deadfish(Prog, I2).
 deadfish([d | Prog], I) -->
 {
 I1 is I - 1,
 deadfish_(I1, I2)
 },
 deadfish(Prog, I2).
 deadfish([s | Prog], I) -->
 {
 I1 is I * I,
 deadfish_(I1, I2)
 },
 deadfish(Prog, I2).
 
 deadfish_(I, I) :-
 dif(I, -1),
 dif(I, 256).
 deadfish_(-1, 0).
 deadfish_(256, 0).
This prolog implementation is fully pure and can be used to evaluate, generate and test deadfish programs. 
== Pure ==
 using system;
 fish a "i" = a+1;
 fish a "d" = a-1;
 fish a "s" = a*a;
 fish a "o" = a when puts (str a) end;
 limit a = if a == 256 || a < 0 then 0 else a;
 main a = (printf "%s " ">>") $$ (main (fish (limit a) (gets)));
 main 0;
== Python ==
"""
Deadfish Programming Language Interpreter
Programmed by Jonathan Todd Skinner
This code is hereby released into the public domain
Harry eased the mess
"""
# Initialization
accumulator = 0
# Main program loop
while True:
 # Get user input
 cmd = raw_input('>> ')
 if accumulator == 256 or accumulator == -1:
 # Overflow, reset accumulator
 accumulator = 0
 # Process input
 if cmd == 'i':
 accumulator += 1 # Increment
 elif cmd == 'd':
 accumulator += -1 # Decrement
 elif cmd == 'o':
 print accumulator # Output
 elif cmd == 's':
 accumulator *= accumulator # Square
 else:
 print 'Unrecognized command.'
A shorter one by User:None1 that uses the built-in function exec():
 exec('x=0\n'+'\n'.join([{'i':'x+=1','d':'x-=1','s':'x*=x','o':'print(x)'}[i]+'\nif x in [-1,256]:\n x=0' for i in input()]))
== Python 3.x ==
#!/bin/env python3
'''
Deadfish Interpreter written in python3.
Written by chill0r.
Everything is free to use - no restrictions.
Startup arguments:
	-strict: Output errors (and abort) on invalid characters and Overflow
	-p program: Execute program (does not exit if not told so)
	
Accepted characters (case sensitive!):
	i / x: increment by 1
	d: decrement by 1
	s / k: square
	o / c: print accumulator
	h: exit interpreter (and stop program) (non standard)
	r: reset accumulator to 0 (non standard)
'''
import sys
class DeadfishError(Exception):	
	def __init__(self, message):
		print(message)
		sys.exit(1)
prog = sys.argv[sys.argv.index('-p')+1] if '-p' in sys.argv else None
strict = '-strict' in sys.argv
acc = 0
i = 0
print(Python3 Deadfish interpreter version 0.1)
while True:
	if not bool(prog):
		prog = input('>>')
	for char in prog:
		if strict and not char in ['i', 'x', 'd', 's', 'k', 'h', 'o', 'c', 'r']:
			raise DeadfishError('Invalid character {} at index {}'.format(char, i))
		if char in ['i','x']:
			acc += 1
		elif char == 'd':
			acc -= 1
		elif char in ['s', 'k']:
			acc *= acc
		elif char == 'h':
			print('Long live the fish!')
			sys.exit(0)
		elif char == 'r':
			acc = 0
		if acc < 0 or acc == 256:
			if strict:
				raise DeadfishError('Overflow at char {} (Index {}) accumulator = {}'.format(char, i, acc))
			else:
				acc = 0
		if char in ['o', 'c']:
			print(acc)
		i += 1
	prog = None
	i = 0
another one:
#Deadfish Interpreter by User:Asdf (Prints X when error)
a=0
while 1:
 c=input()
 if a==256 or a<0:
 a=0
 if c=='i':
 a+=1
 elif c=='d':
 a-=1
 elif c=='o':
 print(a)
 elif c=='s':
 a*=a
 else:
 print('X')
Yet another one by User:Tux1
accumulator = 0
while True:
 command = input(">> ")
 if accumulator == 256 or accumulator == -1:
 accumulator = 0
 if command == "i":
 accumulator += 1
 elif command == "d":
 accumulator -= 1
 elif command == "s":
 accumulator **= 2
 elif command == "o":
 print(accumulator)
And another one with built in halting... -User:Myoitzi 
string = input()
run = 1
a = 0
num = 0
maxnum = len(string)
while run == 1:
 if a == -1:
 a = 0
 if a == 256:
 a = 0
 if num < maxnum:
 if string[num] == 'i':
 a = a+1
 num = num+1
 elif string[num] == 'd':
 a = a-1
 num = num+1
 elif string[num] == 's':
 a = a*a
 num = num+1
 elif string[num] == 'o':
 print(a)
 num = num+1
 else:
 num = num+1
 else:
 run = 0
== QuickBasic/QBasic/QB64 ==
Takes input as arguments from the command-line.
PRG$ = COMMAND$
FOR I& = 0 TO LEN(PRG$)
 SELECT CASE MID$(PRG$, I&, 1)
 CASE "i": A% = A% + 1
 CASE "d": A% = A% - 1
 CASE "s": A% = A% * A%
 CASE "o": PRINT CHR$(A%);
 CASE "h": SYSTEM
 CASE ELSE: PRINT
 END SELECT
 IF (A% AND 255) <> A% THEN A% = 0 'A less resource-intensive way of checking if it is not equal to
NEXT
== R ==
n <- 0
while(TRUE) {
 if(n==-1 || n==256) n <- 0
 cmd <- scan(n=1,what='character')
 fun <- switch(cmd,
 d=function(x) x-1,
 i=function(x) x+1,
 o=function(x) { cat(x,"\n"); x },
 s=function(x) x*x)
 if(!is.null(fun)) n <- fun(n)
}
Another interpreter:
#This uses normal commands, xkcd commands, and h.
num <- 0 # accumulator
keep_going <- TRUE # indicates to keep going
while(keep_going){
 # Cat prints formatted strings.
 cat('Enter code:')
 
 # You can add one whole line of code.
 # The line can include spaces and ends at a newline
 entered_code <- scan(nlines=1,what='character')
 
 # This allows the members of the character vector
 # to be interpreted as a single string.
 entered_code <- paste(entered_code, collapse = " ")
 
 # This for-loop analyses each command.
 for(pointer in 1:nchar(entered_code)){
 letter <- substr(entered_code,pointer,pointer)
 
 # This outputs each input command.
 cat(paste('>> ',letter,'\n',sep=))
 
 if(letter %in% c("i","x")){num <- num + 1}
 else if(letter %in% c("s","k")){num <- num * num}
 else if(letter %in% c("o","c")){cat(paste(num,'\n',sep=))}
 else if(letter == "d"){num <- num - 1}
 else if(letter == "h"){keep_going <- FALSE;break}
 
 if(num == -1 | num == 256){num <- 0}
 }
}
== Racket ==
This code can infinitely take input and give output, and has implementation for the h command.
#lang racket
(define acc 0)
(define (deadfish str)
 (for ([char (in-string str)])
 (cond
 [(string=? (string char) "d") (set! acc (- acc 1))]
 [(string=? (string char) "i") (set! acc (+ acc 1))]
 [(string=? (string char) "s") (set! acc (expt acc 2))]
 [(string=? (string char) "o") (printf "~a~%" acc)]
 [(string=? (string char) "h")
 (when (or (= acc -1) (= acc 256))
 (set! acc 0))]
 [else 0])))
(define (main)
 (when true
 (printf ">>")
 (deadfish (read-line))
 (main)))
(main)
;; by Blair Myhre
== Rainbo ==
 ;; deadfish repl (deadfish with Halt command)
 (require std/io std/math)
 (mut (def acc 0))
 (mut (def input :undefined))
 (defn eval-dfish (str)
 (forstring str char
 (if (str=? char "d")
 (-- acc)
 (if (str=? char "i")
 (++ acc)
 (if (str=? char "s")
 (** acc 2)
 (if (str=? char "o")
 (printf acc)
 (if (str=? char "h")
 (mut! acc 0)
 'neval)))))))
 {(printf "Deadfish in Rainbo, by Blair Myhre~n")
 (when (:true)
 (printf "~n>> ")
 (mut! input (readline))
 (eval-dfish input))}
== Raku ==
use v6.d;
# set accumulator as a defined integer
my Int:D $acc = 0;
# loop forever
loop {
 # get a line of input with a prompt of >>
 my Str:D $input = prompt ">> ";
 # iterate and map a function over each character
 $input.comb.map(-> $command {
 # switch statement with pattern matching and no fallthrough
 given $command {
 # check if command is either "i" or "x" and increment acc
 when "i" | "x" {
 ++$acc
 }
 # decrement acc
 when "d" {
 --$acc
 }
 # square acc
 when "s" | "k" {
 $acc **= 2
 }
 # print acc with newline
 when "o" | "c" {
 say $acc
 }
 # exit with exit status 0
 when "h" {
 exit
 }
 }
 # set acc to 0 if it is -1 or 256 after command
 $acc = $acc == -1 | 256 ?? 0 !! $acc
 })
}
== REBOL 3 ==
f: does [if a = -1 or (a = 256) [a: 0]]
d: [
 any [
 ["i"|"x"] (++ a f) |
 ["d"] (-- a f) |
 ["s"|"k"] (a: a * a f) |
 ["o"|"c"] (print a) |
 skip
 ]
]
a: 0 
forever [parse (ask ">>") d]
== Rexx ==
Derived from Deadfish in Zeno (in turn derived from Deadfish in Turing, a.k.a. "Deadfish in Deadfish"), then modified slightly with respect to whitespace to make it "reasonably" compact.
/* Deadfish in Rexx -- dnm 2021-06-04 */
accumulator = 0
do forever
 if (accumulator = 256) | (accumulator < 0) then accumulator = 0
 call charout ,">> " ; parse pull command
 select
 when command == "i" then accumulator = accumulator + 1
 when command == "d" then accumulator = accumulator - 1
 when command == "s" then accumulator = accumulator * accumulator
 when command == "o" then say accumulator
 otherwise say "Unrecognized command"
 end
end
== Ruby ==
Implementation by Abe Voelker
#!/usr/bin/env ruby
 
n = 0
while true
 print '>> '
 gets.chomp.each_char do |c|
 n = 0 if [-1, 256].include?(n)
 case c
 when 'd' then n -= 1
 when 'i' then n += 1
 when 'o' then puts n
 when 's' then n *= n
 end
 end
end
Here is an implementation that doesn't return an error, and produces more clear output, by Areallycoolusername.
acc = 0
i = nil
while i != 'h' 
 print '>> '
 i = gets.chomp
 if i == 'i' then acc += 1
 	puts "\n"
 end
 if i == 'd' then acc -= 1
 	puts "\n"
 end
 if i == 's' then acc *= acc
 	puts "\n"
 end
 if i == 'o' then puts "#{acc}\n" end
 if acc < 0 || acc == 256 then acc = 0 end
end
== Rust ==
use std::io::{self, Write};
fn main() -> io::Result<()> {
 let stdin = io::stdin();
 let mut input = String::new();
 let mut acc: i64 = 0;
 loop {
 print!(">> ");
 io::stdout().flush()?;
 input.clear();
 stdin.read_line(&mut input)?;
 for ch in input.chars() {
 match ch {
 'i' => acc += 1,
 'd' => acc -= 1,
 'o' => println!("{acc}"),
 's' => acc *= acc,
 _ => println!(),
 }
 }
 if acc < 0 || acc == 256 {
 acc = 0;
 }
 }
}
== Robin ==
Runs under Robin 0.3 to (at least) Robin 0.7. Requires stdlib to be loaded before running. Does not accept more than one command per line.
<nowiki>
(reactor (line-terminal) 0
 (macro (self args env)
 (bind event (head args)
 (bind event-type (head event)
 (bind event-payload (head (tail event))
 (bind prev-state (head (tail args))
 (bind state
 (if (equal? prev-state (subtract 0 1))
 0
 (if (equal? prev-state 256)
 0
 prev-state))
 (bind prompt (macro (self args env)
 (bind show (eval env (head args))
 (bind state (eval env (head (tail args)))
 (if show
 (list state
 (list (literal writeln) (itoa state))
 (list (literal write) (literal >> )))
 (list state
 (list (literal write) (literal >> )))))))
 (choose
 ((equal? event-type (literal init))
 (prompt #f state))
 ((equal? event-type (literal readln))
 (bind letter event-payload
 (choose
 ((equal? letter (literal d))
 (prompt #f (subtract state 1)))
 ((equal? letter (literal i))
 (prompt #f (subtract state (subtract 0 1))))
 ((equal? letter (literal s))
 (prompt #f (multiply state state)))
 ((equal? letter (literal o))
 (prompt #t state))
 (else (prompt state)))))
 (else
 (list state)))))))))))
</nowiki>
== Rockstar ==
The beginning is perfection.
Perfection is an alert fisher.
The end is perfection.
Desperate is a mysterious individual.
Burn it.
Innocent is a respectful horse.
Burn it.
Savage are a contestant's words.
Burn it.
Honest is a proposition unfulfilled.
Burn it.
Listen to the fish.
Cut it.
The man is respectful.
While the man is weaker than the fish,
let the story be the fish at the man
if the story is innocent
build the end up
if the story is desperate
knock the end down
if the story is savage
let the end be of the end
if the story is honest
say the end
if the end is weaker than the beginning
the end is perfection
if the end is perfection
the end is perfection
Build the man up
== Röda ==
{i=0;chars|{|k|i++if[k="i"];i--if[k="d"];i*=i if[k="s"];print i if[k="o"];i=0 if[i=-1 or i=256]}_}
== Sakana ==
i増作d減作s乗作o出作コ魚繰作
== The language defined by the Revised Revised Revised Revised Revised Report on the Algorithmic Language Scheme ==
<nowiki>(define (execute n cmd)
 (case cmd
 ((#\i) (+ n 1))
 ((#\d) (- n 1))
 ((#\s) (* n n))
 ((#\o) (display n) (newline) n)
 (else n)))
(define (deadfish n)
 (let ((char (read-char)))
 (cond
 ((or (= n -1) (= n 256)) (deadfish 0))
 ((eof-object? char) n)
 (else (deadfish (execute n char))))))
(deadfish 0)</nowiki>
== Scratch 3.0 ==
Here
== Seabass ==
iisibCmbCZbmbbCZbmbbbCZbmbbbbCbcazZZxnzZaCaczciZxbbIIIIZnzZaCaczciiiZxaxzcaxziibIIIIbIIIZTaxzcaxziiibIIIIbIIIZTaxzcaxziiiibIIIIbIIIZTaxzcaxzbbIIIIZTzZaCaczcbIZxbIbIIIIZnzZaCaczcibIZxbbIIIIZnzZaCaczciibIZxbIIIbIIIIZnzZaCaczciiibIZxibIIbIIIIZnzZaCaczciiiibIZxnzZaCaczcbIIZxnzZaCaczcibIIZxbIbbIIZnzZaCaczciibIIZxaxzcaxziibIIbIIZTaxzcaxziibIIbIIZTzZaCaczciiibIZ;zZaCaczciibIIZxiiiZQzZaCaczciibIZ;zZaCaczcixlxaaxzcxlaaxz{zZaCaczciiiiZxnzZaCaczcxlaCzxiii#aCzxiiiiad=i>.izxT>zZaCaczcbIZxlxaaxzciiiixlaaxz=zZaCaczciiiibIZxlinzZaCaczc>zZaCaczcibIZxlxaaxzciiiixlaaxz=zZaCaczciiiibIZxldnzZaCaczc>zZaCaczciibIZxlxaaxzciiiixlaaxz=zZaCaczciiiibIZxlsfzZaCaczc>zZaCaczciiibIZxlxaaxzciiiixlaaxz=zZaCaczciiiibIgOzZaCaczc>zZaCaczcbIIZxlxaaxzciiiibIZxlaaxz=zZaCaczcbIIZxlaCzxiiiibIZxfzZaCaczc>zZaCaczcibIIZxlxaaxzciiiibIZxlaaxz=zZaCaczcibIIZxlaCzxiiiibIZxfzZaCaczc>zZaCaczcZxlinzZaCaczciibIZjzZaCaczc>zZaCaczcZxnzZaCaczciiibIZjzZaCaczc
== (GNU) sed ==
Takes input on separate lines.
 G
 s/i./;/
 s/d.;\?//
 /o/{g
 :b;s/\n\?;\{10\}/;\n/;tb
 s/$/0123456789w/mg
 :a;s/;\w//;ta
 s/\B\w*\n*//gp
 x}
 /s/{g;:c;/^;/G;s///;tc;s/\n//g}
 s/^;\{256\}$//;x;d
== Seed7 ==
This version includes the optional halt command (for if this was not included, you would need to press Ctrl+C, then *, to exit the interpreter. Or enter a blank line to make it crash.) This is not really conformant as the spec says that errors are ignored
 $ include "seed7_05.s7i";
 include "stdio.s7i";
 
 var boolean: keep_going is TRUE;
 var integer: accumulator is 0;
 var string: command is "";
 
 const proc: main is func
 begin
 while keep_going do
 if accumulator = 256 or accumulator < 0 then
 accumulator := 0;
 end if;
 write(">> ");
 readln(command);
 case command[1] of
 when {'s'}: accumulator := accumulator * accumulator;
 when {'o'}: writeln(accumulator);
 when {'i'}: accumulator := accumulator + 1;
 when {'d'}: accumulator := accumulator - 1;
 when {'h'}: keep_going := FALSE;
 otherwise: writeln("STOP CONFUSING ME");
 end case;
 end while;
 end func;
A more awesome version of this implementation would use Seed7's ability to create new program structures.
== S-Lang ==
 #!/usr/bin/env slsh
 
 variable l=" ", n=0, r;
 forever {
 if (n==-1||n==256) n=0;
 r=fputs(">> ", stdout);
 r=fgets(&l, stdin);
 switch (l[0])
 { case 'd': n--; }
 { case 'i': n++; }
 { case 'o': print(n); }
 { case 's': n=n*n; }
 }
 }
Protip 1: if you do not do something with the result of fputs and fgets (assign them to the scratch variable r in this case), slsh eventually runs out of stack space.
Protip 2: the braces in the above program are not matched correctly. slsh does not seem to care.
== Selt ==
# https://esolangs.org/wiki/Deadfish
loop:
 print \>\>\ 
 input = @stdin
 index = 0
 goto inloop~(@input != `) # jump to end when input is empty
 inloop1:
 goto @input.@index # go to the label corresponding to each command
 i:val = @val+1
 goto end
 d:val = @val-1
 goto end
 s:val = @val*@val
 goto end
 o:println @val
 goto end
 end:goto reset~((@val == \-1) || (@val == 256))
 reset1:val = 0
 reset0:
 index = @index+1
 goto inloop~(@index < ?@input)
 inloop0: goto loop
index:0
val:0
input:
== Shakespeare ==
Tested on the tio.run implementation. Written by User:BoundedBeans
<nowiki>
A Shakespearean Depiction of a Deceased Fish;
----------------------------------------------------
This is a Deadfish interpreter written in Shakespeare;
End the program with a pipe character ('|');
Methinks this is the end of this wretched commentary.
Romeo, the program stack.
Lady Macbeth, a helper stack.
Juliet, the register.
Hamlet, for checking ASCII codes.
Act I: The lone wolf act (other than halting).
Scene I: Startup.
[Enter Romeo and Lady Macbeth]
 Lady Macbeth:
 You are nothing!
 Remember yourself!
 Romeo:
 You are nothing!
 Remember yourself!
[Exit Lady Macbeth]
[Enter Juliet]
 Romeo:
 You are nothing!
 Let us proceed to Scene II.
Scene II: The input loop.
[Exeunt]
[Enter Romeo and Lady Macbeth]
 Romeo:
 Open your mind! 
[Exit Romeo]
[Enter Hamlet]
 Lady Macbeth:
 You are the difference between a big big big big big big big cat and a big big cat! 
 Am I as good as you?
 Hamlet:
 If so, let us proceed to Scene III. 
 Remember yourself!
 Lady Macbeth:
 Let us proceed to Scene II.
Scene III: Transfer stack from Lady Macbeth to Romeo to reverse the input data.
[Exeunt]
[Enter Romeo and Lady Macbeth]
 Romeo:
 Recall your wretched nightmare!
 Lady Macbeth:
 Am I as good as nothing?
 Romeo:
 If so, let us proceed to Scene IV.
 Lady Macbeth:
 Remember me!
 Let us proceed to Scene III.
Scene IV: Main interpretation.
[Exeunt]
[Enter Romeo and Hamlet]
 Hamlet:
 Recall the king's treason!
 Romeo:
 Am I as good as nothing?
 Hamlet:
 If so, let us proceed to Act II.
 Romeo: 
 You are the sum of a cat and a big big big cat!
 You are the sum of thyself and a big big big big big cat.
 You are the sum of thyself and a big big big big big big cat. 
 Am I as good as you?
 Hamlet:
 If so, let us proceed to Scene V.
 Romeo:
 You are the square of the sum of a big big big cat and a big cat!
 Am I as good as you?
 Hamlet:
 If so, let us proceed to Scene VI.
 Romeo:
 You are the sum of a cat and a big cat!
 You are the sum of thyself and a big big big big cat!
 You are the sum of thyself and a big big big big big cat!
 You are the sum of thyself and a big big big big big big cat! 
 Am I as good as you?
 Hamlet:
 If so, let us proceed to Scene VII.
 Romeo:
 You are the difference between yourself and a big big cat!
 Am I as good as you?
 Hamlet:
 If so, let us proceed to Scene VIII.
 Romeo:
 Let us proceed to Scene IV.
Scene V: The 'i' command.
[Exeunt]
[Enter Romeo and Juliet]
 Romeo:
 You are the sum of yourself and a cat!
 Let us proceed to Scene IX.
Scene VI: The 'd' command.
[Exeunt]
[Enter Romeo and Juliet]
 Romeo:
 You are the difference between yourself and a cat!
 Let us proceed to Scene IX.
Scene VII: The 's' command.
[Exeunt]
[Enter Romeo and Juliet]
 Romeo:
 You are the product of yourself and yourself!
 Let us proceed to Scene IX.
Scene VIII: The 'o' command.
[Exeunt]
[Enter Romeo and Juliet]
 Romeo:
 Open your heart! 
 Remember yourself.
 You are the sum of a big big big cat and a big cat.
 Speak your mind!
 Recall yourself.
 Let us proceed to Scene IX.
Scene IX: 256 or -1 checker.
[Exeunt]
[Enter Hamlet and Juliet]
 Juliet:
 You are a big big big big big big big big cat!
 Am I as good as you? 
 If so, let us proceed to Scene X. 
 You are the difference between nothing and a cat!
 Am I as good as you?
 If so, let us proceed to Scene X.
 Let us proceed to Scene IV.
Scene X: Casting Juliet into the abyss.
[Exeunt]
[Enter Hamlet and Juliet]
 Hamlet:
 You are nothing!
 Let us proceed to Scene IV.
Act II: The Halting.
Scene I: The only scene in The Halting.
[Exeunt]
</nowiki>
== SmileBASIC ==
Takes a line from stdin and runs all characters in said line. Unrecognized commands print a newline. Commands are case-sensitive, lowercase. Implements h and proper x==0||x==256 behavior.
OPTION STRICT
'declare vars
VAR X%
VAR S$,C$
'REPL loop
REPEAT
 LINPUT ">> ";S$ 'get line from stdin
 'exec all chrs in line
 WHILE LEN(S$)!=0
 C$=SHIFT(S$) 'pop chr from front of string
 IF C$=="i" THEN
 INC X%
 ELSEIF C$=="d" THEN
 DEC X%
 ELSEIF C$=="s" THEN
 'square x
 X%=X%*X%
 ELSEIF C$=="o" THEN
 'output x
 PRINT X%
 ELSEIF C$=="h" THEN
 BREAK
 ELSE
 PRINT 'adds a newline
 ENDIF
 IF X%<0||X%>255 THEN X%=0 'zero behavior
 WEND
UNTIL C$=="h"
== SNUSP ==
 /@@@=@@@=++++#	100 = 5*5*4 = 'd'
 / | \! \
$=!\>,+?!#-=>@/=!/?!\<?\>!/?\<</ |
 eof? 'd' \->| -/ \-/ |
 \<?\==!=== < -/
 'i'/ +++++>/ | !
 \ !/?!\<?\> / |
 \->| -/ ! |
 \<?\==|== < +/
 'o'/ ++++++>/ | !
 \ !/?!\<?\> / |
 \->| -/ ! |
 \<?\==|== < ./
 's'/ ++++>/ | !
 \ !/?!\<?\> / |
 \->| -/ |
 /= square = < = /?</ |
 | /======= > =!\ noop =!/== < /
 | | / ++<+<\ |
 \?!/>>+<<-?\>!/>-?/<<+>?!/>+<\
 \ up2 / \ \?- /
== SOAP ==
This will only run in the copied implementation. You will need to follow the steps listed on the SOAP page, it's not as simple as inputting the program.
This supports numbers up to 299. Suffix with a period.
*1*102011⊇{102011}[
 ~
 'i/*%:*%⊇{100112}[*%;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*%]\
 'd/*%;*%⊇{100112}[*%;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*%]\
 's/
 *102012
 ⊇{10,102012}[*%::*%*102012]
 ⊇{11,102012}[*%::::::*%*102012]
 ⊇{12,102012}[*%::::::::::::*%*102012]
 ⊇{20,102012}[*%::::::::::::::::::::*%*102012]
 ⊇{21,102012}[*%::::::::::::::::::::::::::::::*%*102012]
 ⊇{22,102012}[*%::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{100,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{101,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{102,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{110,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{111,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{112,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{120,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{121,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{122,102012}[*%;;;;;;;;;;;;;;;;*%*102012]
 ⊇{200,102012}[*%::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*%*102012]
 ⊇{102012}[*102012]
 \
 'o/
 *102012
 ⊇{1,102012}["0*102012]
 ⊇{2,102012}["1*102012]
 ⊇{10,102012}["2*102012]
 ⊇{11,102012}["3*102012]
 ⊇{12,102012}["4*102012]
 ⊇{20,102012}["5*102012]
 ⊇{21,102012}["6*102012]
 ⊇{22,102012}["7*102012]
 ⊇{100,102012}["8*102012]
 ⊇{101,102012}["9*102012]
 ⊇{102,102012}["1"0*102012]
 ⊇{110,102012}["1"1*102012]
 ⊇{111,102012}["1"2*102012]
 ⊇{112,102012}["1"3*102012]
 ⊇{120,102012}["1"4*102012]
 ⊇{121,102012}["1"5*102012]
 ⊇{122,102012}["1"6*102012]
 ⊇{200,102012}["1"7*102012]
 ⊇{201,102012}["1"8*102012]
 ⊇{202,102012}["1"9*102012]
 ⊇{210,102012}["2"0*102012]
 ⊇{211,102012}["2"1*102012]
 ⊇{212,102012}["2"2*102012]
 ⊇{220,102012}["2"3*102012]
 ⊇{221,102012}["2"4*102012]
 ⊇{222,102012}["2"5*102012]
 ⊇{1000,102012}["2"6*102012]
 ⊇{1001,102012}["2"7*102012]
 ⊇{1002,102012}["2"8*102012]
 ⊇{1010,102012}["2"9*102012]
 ⊇{1011,102012}["3"0*102012]
 ⊇{1012,102012}["3"1*102012]
 ⊇{1020,102012}["3"2*102012]
 ⊇{1021,102012}["3"3*102012]
 ⊇{1022,102012}["3"4*102012]
 ⊇{1100,102012}["3"5*102012]
 ⊇{1101,102012}["3"6*102012]
 ⊇{1102,102012}["3"7*102012]
 ⊇{1110,102012}["3"8*102012]
 ⊇{1111,102012}["3"9*102012]
 ⊇{1112,102012}["4"0*102012]
 ⊇{1120,102012}["4"1*102012]
 ⊇{1121,102012}["4"2*102012]
 ⊇{1122,102012}["4"3*102012]
 ⊇{1200,102012}["4"4*102012]
 ⊇{1201,102012}["4"5*102012]
 ⊇{1202,102012}["4"6*102012]
 ⊇{1210,102012}["4"7*102012]
 ⊇{1211,102012}["4"8*102012]
 ⊇{1212,102012}["4"9*102012]
 ⊇{1220,102012}["5"0*102012]
 ⊇{1221,102012}["5"1*102012]
 ⊇{1222,102012}["5"2*102012]
 ⊇{2000,102012}["5"3*102012]
 ⊇{2001,102012}["5"4*102012]
 ⊇{2002,102012}["5"5*102012]
 ⊇{2010,102012}["5"6*102012]
 ⊇{2011,102012}["5"7*102012]
 ⊇{2012,102012}["5"8*102012]
 ⊇{2020,102012}["5"9*102012]
 ⊇{2021,102012}["6"0*102012]
 ⊇{2022,102012}["6"1*102012]
 ⊇{2100,102012}["6"2*102012]
 ⊇{2101,102012}["6"3*102012]
 ⊇{2102,102012}["6"4*102012]
 ⊇{2110,102012}["6"5*102012]
 ⊇{2111,102012}["6"6*102012]
 ⊇{2112,102012}["6"7*102012]
 ⊇{2120,102012}["6"8*102012]
 ⊇{2121,102012}["6"9*102012]
 ⊇{2122,102012}["7"0*102012]
 ⊇{2200,102012}["7"1*102012]
 ⊇{2201,102012}["7"2*102012]
 ⊇{2202,102012}["7"3*102012]
 ⊇{2210,102012}["7"4*102012]
 ⊇{2211,102012}["7"5*102012]
 ⊇{2212,102012}["7"6*102012]
 ⊇{2220,102012}["7"7*102012]
 ⊇{2221,102012}["7"8*102012]
 ⊇{2222,102012}["7"9*102012]
 ⊇{10000,102012}["8"0*102012]
 ⊇{10001,102012}["8"1*102012]
 ⊇{10002,102012}["8"2*102012]
 ⊇{10010,102012}["8"3*102012]
 ⊇{10011,102012}["8"4*102012]
 ⊇{10012,102012}["8"5*102012]
 ⊇{10020,102012}["8"6*102012]
 ⊇{10021,102012}["8"7*102012]
 ⊇{10022,102012}["8"8*102012]
 ⊇{10100,102012}["8"9*102012]
 ⊇{10101,102012}["9"0*102012]
 ⊇{10102,102012}["9"1*102012]
 ⊇{10110,102012}["9"2*102012]
 ⊇{10111,102012}["9"3*102012]
 ⊇{10112,102012}["9"4*102012]
 ⊇{10120,102012}["9"5*102012]
 ⊇{10121,102012}["9"6*102012]
 ⊇{10122,102012}["9"7*102012]
 ⊇{10200,102012}["9"8*102012]
 ⊇{10201,102012}["9"9*102012]
 ⊇{10202,102012}["1"0"0*102012]
 ⊇{10210,102012}["1"0"1*102012]
 ⊇{10211,102012}["1"0"2*102012]
 ⊇{10212,102012}["1"0"3*102012]
 ⊇{10220,102012}["1"0"4*102012]
 ⊇{10221,102012}["1"0"5*102012]
 ⊇{10222,102012}["1"0"6*102012]
 ⊇{11000,102012}["1"0"7*102012]
 ⊇{11001,102012}["1"0"8*102012]
 ⊇{11002,102012}["1"0"9*102012]
 ⊇{11010,102012}["1"1"0*102012]
 ⊇{11011,102012}["1"1"1*102012]
 ⊇{11012,102012}["1"1"2*102012]
 ⊇{11020,102012}["1"1"3*102012]
 ⊇{11021,102012}["1"1"4*102012]
 ⊇{11022,102012}["1"1"5*102012]
 ⊇{11100,102012}["1"1"6*102012]
 ⊇{11101,102012}["1"1"7*102012]
 ⊇{11102,102012}["1"1"8*102012]
 ⊇{11110,102012}["1"1"9*102012]
 ⊇{11111,102012}["1"2"0*102012]
 ⊇{11112,102012}["1"2"1*102012]
 ⊇{11120,102012}["1"2"2*102012]
 ⊇{11121,102012}["1"2"3*102012]
 ⊇{11122,102012}["1"2"4*102012]
 ⊇{11200,102012}["1"2"5*102012]
 ⊇{11201,102012}["1"2"6*102012]
 ⊇{11202,102012}["1"2"7*102012]
 ⊇{11210,102012}["1"2"8*102012]
 ⊇{11211,102012}["1"2"9*102012]
 ⊇{11212,102012}["1"3"0*102012]
 ⊇{11220,102012}["1"3"1*102012]
 ⊇{11221,102012}["1"3"2*102012]
 ⊇{11222,102012}["1"3"3*102012]
 ⊇{12000,102012}["1"3"4*102012]
 ⊇{12001,102012}["1"3"5*102012]
 ⊇{12002,102012}["1"3"6*102012]
 ⊇{12010,102012}["1"3"7*102012]
 ⊇{12011,102012}["1"3"8*102012]
 ⊇{12012,102012}["1"3"9*102012]
 ⊇{12020,102012}["1"4"0*102012]
 ⊇{12021,102012}["1"4"1*102012]
 ⊇{12022,102012}["1"4"2*102012]
 ⊇{12100,102012}["1"4"3*102012]
 ⊇{12101,102012}["1"4"4*102012]
 ⊇{12102,102012}["1"4"5*102012]
 ⊇{12110,102012}["1"4"6*102012]
 ⊇{12111,102012}["1"4"7*102012]
 ⊇{12112,102012}["1"4"8*102012]
 ⊇{12120,102012}["1"4"9*102012]
 ⊇{12121,102012}["1"5"0*102012]
 ⊇{12122,102012}["1"5"1*102012]
 ⊇{12200,102012}["1"5"2*102012]
 ⊇{12201,102012}["1"5"3*102012]
 ⊇{12202,102012}["1"5"4*102012]
 ⊇{12210,102012}["1"5"5*102012]
 ⊇{12211,102012}["1"5"6*102012]
 ⊇{12212,102012}["1"5"7*102012]
 ⊇{12220,102012}["1"5"8*102012]
 ⊇{12221,102012}["1"5"9*102012]
 ⊇{12222,102012}["1"6"0*102012]
 ⊇{20000,102012}["1"6"1*102012]
 ⊇{20001,102012}["1"6"2*102012]
 ⊇{20002,102012}["1"6"3*102012]
 ⊇{20010,102012}["1"6"4*102012]
 ⊇{20011,102012}["1"6"5*102012]
 ⊇{20012,102012}["1"6"6*102012]
 ⊇{20020,102012}["1"6"7*102012]
 ⊇{20021,102012}["1"6"8*102012]
 ⊇{20022,102012}["1"6"9*102012]
 ⊇{20100,102012}["1"7"0*102012]
 ⊇{20101,102012}["1"7"1*102012]
 ⊇{20102,102012}["1"7"2*102012]
 ⊇{20110,102012}["1"7"3*102012]
 ⊇{20111,102012}["1"7"4*102012]
 ⊇{20112,102012}["1"7"5*102012]
 ⊇{20120,102012}["1"7"6*102012]
 ⊇{20121,102012}["1"7"7*102012]
 ⊇{20122,102012}["1"7"8*102012]
 ⊇{20200,102012}["1"7"9*102012]
 ⊇{20201,102012}["1"8"0*102012]
 ⊇{20202,102012}["1"8"1*102012]
 ⊇{20210,102012}["1"8"2*102012]
 ⊇{20211,102012}["1"8"3*102012]
 ⊇{20212,102012}["1"8"4*102012]
 ⊇{20220,102012}["1"8"5*102012]
 ⊇{20221,102012}["1"8"6*102012]
 ⊇{20222,102012}["1"8"7*102012]
 ⊇{21000,102012}["1"8"8*102012]
 ⊇{21001,102012}["1"8"9*102012]
 ⊇{21002,102012}["1"9"0*102012]
 ⊇{21010,102012}["1"9"1*102012]
 ⊇{21011,102012}["1"9"2*102012]
 ⊇{21012,102012}["1"9"3*102012]
 ⊇{21020,102012}["1"9"4*102012]
 ⊇{21021,102012}["1"9"5*102012]
 ⊇{21022,102012}["1"9"6*102012]
 ⊇{21100,102012}["1"9"7*102012]
 ⊇{21101,102012}["1"9"8*102012]
 ⊇{21102,102012}["1"9"9*102012]
 ⊇{21110,102012}["2"0"0*102012]
 ⊇{21111,102012}["2"0"1*102012]
 ⊇{21112,102012}["2"0"2*102012]
 ⊇{21120,102012}["2"0"3*102012]
 ⊇{21121,102012}["2"0"4*102012]
 ⊇{21122,102012}["2"0"5*102012]
 ⊇{21200,102012}["2"0"6*102012]
 ⊇{21201,102012}["2"0"7*102012]
 ⊇{21202,102012}["2"0"8*102012]
 ⊇{21210,102012}["2"0"9*102012]
 ⊇{21211,102012}["2"1"0*102012]
 ⊇{21212,102012}["2"1"1*102012]
 ⊇{21220,102012}["2"1"2*102012]
 ⊇{21221,102012}["2"1"3*102012]
 ⊇{21222,102012}["2"1"4*102012]
 ⊇{22000,102012}["2"1"5*102012]
 ⊇{22001,102012}["2"1"6*102012]
 ⊇{22002,102012}["2"1"7*102012]
 ⊇{22010,102012}["2"1"8*102012]
 ⊇{22011,102012}["2"1"9*102012]
 ⊇{22012,102012}["2"2"0*102012]
 ⊇{22020,102012}["2"2"1*102012]
 ⊇{22021,102012}["2"2"2*102012]
 ⊇{22022,102012}["2"2"3*102012]
 ⊇{22100,102012}["2"2"4*102012]
 ⊇{22101,102012}["2"2"5*102012]
 ⊇{22102,102012}["2"2"6*102012]
 ⊇{22110,102012}["2"2"7*102012]
 ⊇{22111,102012}["2"2"8*102012]
 ⊇{22112,102012}["2"2"9*102012]
 ⊇{22120,102012}["2"3"0*102012]
 ⊇{22121,102012}["2"3"1*102012]
 ⊇{22122,102012}["2"3"2*102012]
 ⊇{22200,102012}["2"3"3*102012]
 ⊇{22201,102012}["2"3"4*102012]
 ⊇{22202,102012}["2"3"5*102012]
 ⊇{22210,102012}["2"3"6*102012]
 ⊇{22211,102012}["2"3"7*102012]
 ⊇{22212,102012}["2"3"8*102012]
 ⊇{22220,102012}["2"3"9*102012]
 ⊇{22221,102012}["2"4"0*102012]
 ⊇{22222,102012}["2"4"1*102012]
 ⊇{100000,102012}["2"4"2*102012]
 ⊇{100001,102012}["2"4"3*102012]
 ⊇{100002,102012}["2"4"4*102012]
 ⊇{100010,102012}["2"4"5*102012]
 ⊇{100011,102012}["2"4"6*102012]
 ⊇{100012,102012}["2"4"7*102012]
 ⊇{100020,102012}["2"4"8*102012]
 ⊇{100021,102012}["2"4"9*102012]
 ⊇{100022,102012}["2"5"0*102012]
 ⊇{100100,102012}["2"5"1*102012]
 ⊇{100101,102012}["2"5"2*102012]
 ⊇{100102,102012}["2"5"3*102012]
 ⊇{100110,102012}["2"5"4*102012]
 ⊇{100111,102012}["2"5"5*102012]
 ⊇{100112,102012}["2"5"6*102012]
 ⊇{100120,102012}["2"5"7*102012]
 ⊇{100121,102012}["2"5"8*102012]
 ⊇{100122,102012}["2"5"9*102012]
 ⊇{100200,102012}["2"6"0*102012]
 ⊇{100201,102012}["2"6"1*102012]
 ⊇{100202,102012}["2"6"2*102012]
 ⊇{100210,102012}["2"6"3*102012]
 ⊇{100211,102012}["2"6"4*102012]
 ⊇{100212,102012}["2"6"5*102012]
 ⊇{100220,102012}["2"6"6*102012]
 ⊇{100221,102012}["2"6"7*102012]
 ⊇{100222,102012}["2"6"8*102012]
 ⊇{101000,102012}["2"6"9*102012]
 ⊇{101001,102012}["2"7"0*102012]
 ⊇{101002,102012}["2"7"1*102012]
 ⊇{101010,102012}["2"7"2*102012]
 ⊇{101011,102012}["2"7"3*102012]
 ⊇{101012,102012}["2"7"4*102012]
 ⊇{101020,102012}["2"7"5*102012]
 ⊇{101021,102012}["2"7"6*102012]
 ⊇{101022,102012}["2"7"7*102012]
 ⊇{101100,102012}["2"7"8*102012]
 ⊇{101101,102012}["2"7"9*102012]
 ⊇{101102,102012}["2"8"0*102012]
 ⊇{101110,102012}["2"8"1*102012]
 ⊇{101111,102012}["2"8"2*102012]
 ⊇{101112,102012}["2"8"3*102012]
 ⊇{101120,102012}["2"8"4*102012]
 ⊇{101121,102012}["2"8"5*102012]
 ⊇{101122,102012}["2"8"6*102012]
 ⊇{101200,102012}["2"8"7*102012]
 ⊇{101201,102012}["2"8"8*102012]
 ⊇{101202,102012}["2"8"9*102012]
 ⊇{101210,102012}["2"9"0*102012]
 ⊇{101211,102012}["2"9"1*102012]
 ⊇{101212,102012}["2"9"2*102012]
 ⊇{101220,102012}["2"9"3*102012]
 ⊇{101221,102012}["2"9"4*102012]
 ⊇{101222,102012}["2"9"5*102012]
 ⊇{102000,102012}["2"9"6*102012]
 ⊇{102001,102012}["2"9"7*102012]
 ⊇{102002,102012}["2"9"8*102012]
 ⊇{102010,102012}["2"9"9*102012]
 ⊇{102012}[*102012]
 \
 './*102011\
]
== SQL ==
In order to use this program, another program (possibly written in C or some other programming language) must make the INPUT and OUTPUT views to do the necessary things.
PRAGMA RECURSIVE TRIGGERS = 1;
CREATE TABLE `DEADFISH` (`VALUE` INT);
INSERT INTO `DEADFISH` VALUES (0);
CREATE VIEW `INPUT` AS SELECT AS `INPUT`;
CREATE VIEW `OUTPUT` AS SELECT AS `OUTPUT`;
CREATE TRIGGER `INCREMENT` INSTEAD OF INSERT ON `INPUT` WHEN NEW.`INPUT` = 'i' BEGIN
 UPDATE `DEADFISH` SET `VALUE` = `VALUE` + 1;
 UPDATE `DEADFISH` SET `VALUE` = 0 WHERE `VALUE` = 256;
END;
CREATE TRIGGER `DECREMENT` INSTEAD OF INSERT ON `INPUT` WHEN NEW.`INPUT` = 'd' BEGIN
 UPDATE `DEADFISH` SET `VALUE` = `VALUE` - 1 WHERE `VALUE` > 0;
 UPDATE `DEADFISH` SET `VALUE` = 0 WHERE `VALUE` = 256;
END;
CREATE TRIGGER `SQUARE` INSTEAD OF INSERT ON `INPUT` WHEN NEW.`INPUT` = 's' BEGIN
 UPDATE `DEADFISH` SET `VALUE` = `VALUE` * `VALUE`;
 UPDATE `DEADFISH` SET `VALUE` = 0 WHERE `VALUE` = 256;
END;
CREATE TRIGGER `OUTPUT` INSTEAD OF INSERT ON `INPUT` WHEN NEW.`INPUT` = 'o' BEGIN
 INSERT INTO `OUTPUT` SELECT `VALUE` AS `OUTPUT` FROM `DEADFISH`;
END;
== Stackstack ==
 0 ">> " dup while
 dup print swap inputstr
 
 dup "d" eq if swap 1 - endif
 dup "i" eq if swap 1 + endif
 dup "s" eq if swap dup * endif
 dup "o" eq if swap dup tostring 10 char concat print endif
 
 dup -1 eq if pop 0 endif
 dup 256 eq if pop 0 endif
 
 -3 roll pop
 dup endwhile
== Standard ML ==
Supports both the IDSO and XKCD variants. Use ^D or ^C to quit.
(* deadfish.sml: Simple Deadfish interpreter in Standard ML. *)
fun id x = x
fun apply (f, x) = f(x)
fun fixAcc ~1 = 0
 | fixAcc 256 = 0
 | fixAcc n = n
fun inc (output, acc) = (output, fixAcc(acc + 1))
fun dec (output, acc) = (output, fixAcc(acc - 1))
fun square (output, acc) = (output, fixAcc(acc * acc))
fun output (output, acc) = (acc::output, acc)
fun charToFun #"i" = inc
 | charToFun #"x" = inc
 | charToFun #"d" = dec
 | charToFun #"s" = square
 | charToFun #"k" = square
 | charToFun #"o" = output
 | charToFun #"c" = output
 | charToFun _ = id
local
	fun interpret seed program = foldl apply seed (map charToFun (explode program))
in
	fun main _ =
	 let val is = TextIO.stdIn
	 and acc = ref 0
	 fun display (output, acc) =
	 ((app (fn n => print(Int.toString n ^ "\n")) (rev output));
	 (output, acc))
	 in while (print ">> "; not (TextIO.endOfStream is))
	 do acc := #2 (display (interpret ([], !acc) (valOf(TextIO.inputLine is))))
	 end
	val interpret = rev o #1 o interpret ([], 0)
end
== StaPLe ==
 eval;dup;
 [eval;dup;if;swap;[R0;];||;!;+;1;swap;!;-;256;dup;pop;dup;push;ife;swap;
 [drop;pop;+;1;push;];swap;[ife;swap;[drop;pop;-;1;push;];swap;[ife;swap;
 [drop;pop;*;dup;push;];swap;[ife;swap;[putc;10;put;pop;dup;push;];
 swap;[putc;10;];==;"o;];==;"s;dup;];==;"d;dup;];==;"i;dup;getc;];R0;
== Staq ==
 &iiqqq&{o:&iiiqi;@X}{T-!@_x}{i_iT}{D_d}{d?DT}{sqT}{ks}{xi}{co}{>id}
Allows the command sets of both variations.
== *><> ==
 r01[D63.
 >:884**= ?!\~0v
 ^v0~u!?=-10: OD~l0=?!\;
 ^+1I/!?="i":/
 ^ \:"d"=?!\I1-
 ^*:I/!?="s":/
 ^ \:"o"=?!;I:aon
== Stlang ==
Reads one line of input.
 M 0 (i /r f \
 fn f .<+;h d ;t f \
 fn f: .$ \
 fn d \
 fn d:i .$<>I c <> \
 fn d:d .$<>D c <> \
 fn d:s .$<><+* c <> \
 fn d:o .$<><+@<> \
 fn c \
 fn c:256 .$0(i \
 fn c:-1 .$0(i \
== stupidc ==
Input is defined as %PGM.
system(&BE6502);
include(&lcd);
include(&stupidc);
mem(%pgm, "Your program here");
def(%pos);
def(%a);
onreset({
 set(%pos, #0);
 set(%a, #0);
 $lcd.init(&2line);
 forever({
 choose(%pgm@%pos,
 #'i', { inc(%a); }, <255 rolls over to 0 so we don't need to check>
 #'d', {
 if (%a, { dec(%a); }); <Only allow it to be decremented if it's NOT equal to zero>
 },
 #'s', {
 if (?lt(%a, #16), { <Only allow it to be squared if it is less than 16, because 16*16=256.>
 set(%a, *mult(%a, %a));
 }, {
 set(%a, #0);
 });
 },
 #'p', {
 $lcd.printchar(%a);
 },
 &else, {
 $lcd.locate(&l2);
 }
 );
 inc(%a);
 });
});
== stupidExpr ==
(result = {
 def:
 inp, str,
 c, [str: 1],
 pos, ulong,
 a, ubyte.zero /* automatically does zero-out behavior */
 ;
 (i = [input]);
 loop: {
 (c = [charof: inp, pos]);
 (pos ++ 1);
 choose:
 (c = "i"), { (a ++ 1); },
 (c = "d"), { (a -- 1); },
 (c = "s"), { (a = (a * a)); },
 (c = "p"), { print: [chr: a]; },
 { print: "\n"; }
 ;
 if: (pos > [len: inp]), { stop; };
 };
});
== Super ZZ Zero (assembly) ==
	TA $E0
	EQ A,256
	TLET A,0
	LET C,W
	AND C,$5F
	SUB C,'I'
	JNZ C,1F
	ADD A,1
	LET S,0
1H	ADD C,'I'-'D'
	JNZ C,1F
	JZ A,0
	SUB A,1
	LET S,0
1H	SUB C,'S'-'D'
	JNZ C,1F
	MUL A,A
	LET S,0
1H	ADD C,'S'-'O'
	JNZ C,0
	TEXT E,0
	MESS D,A
	LET S,0
== Surtic ==
I chose to have the deadfish code be stored within the string at the very beginning (between the single quotes), though simply accepting an input of a whole program would work with little modification. This example uses the test case that prints 288.
 s0'diissisdo'c9-c10++++fc10[fc10[c10++]]c8++++++++++fc8[fc8[c3+c4+c5+c6+]c10+++c5+c6+]fc8[c8-]c3+++++fc4[c10-]c10++c6+c5+++++lc7:s0?b1(c1<c7)wb1[gc0:s0(c1)?b3(c0==c3)?b4(c0==c4)?b5(c0==c5)?b6(c0==c6)ib3{c2+}ib4{c2-}ib5{fc2[fc2[c8+]]fc2[c2-]fc8[c2+c8-]}ib6{noc2}?b7(c2==c9)?b8(c2==c10)ib7{c2+}ib8{fc2[c2-]}c1+?b1(c1<c7)]
== TailDot ==
Accepts one command at the time
 c,x,>>,v,x,i,x,v,x,e,x,i,28,e,x,d,37,e,x,s,46,e,x,o,53,j,1,a,a,1,e,a,256,57,j,1,s,a,1,e,a,-1,57,j,1,o,a,e,a,256,57,j,1,v,a,j,1,a,a,1,e,a,0,1,s,a,1,e,a,0,1,j,64
or you can use
c,x,>>,v,x,i,x,v,x,e,x,i,28,e,x,d,37,e,x,s,46,e,x,o,53,e,x,#,77,j,1,a,a,1,e,a,256,61,j,1,s,a,1,e,a,-1,61,j,1,o,a,e,a,256,61,j,1,v,a,j,1,a,a,1,e,a,0,1,s,a,1,e,a,0,1,j,68
by User:ChuckEsoteric08 , added by User:Win7HE
== TAVERN ==
INCLUDE standard.inc
<RAM>
0 VARIABLE VALUE
HERE CONSTANT INPUT-TABLE
1 , 4 ALLOT
<ROM>
:START
 BEGIN
 || >> | INPUT-TABLE ACCEPT
 INPUT-TABLE 1 + @ IF
 INPUT-TABLE 2 + @ ?DUP IF
 EXECUTE
 ELSE
 CR
 THEN
 ELSE
 CR
 THEN
 VALUE @ 256 = VALUE @ -1 = OR IF 0 VALUE ! THEN
 AGAIN
;
:: VALUE INCR ; VOCAB I
:: VALUE DECR ; VOCAB D
:: VALUE @ DUP * VALUE ! ; VOCAB S
:: VALUE @ . CR ; VOCAB O
:: QUIT ; VOCAB H
== TeX ==
% Deadfish interpreter in TeX
\catcode32=9\endlinechar=-1
\newcount\accumulator
\def\checkwrapping{
 \ifnum\accumulator=256\accumulator=0\fi
 \relax
 \ifnum\accumulator=-1\accumulator=0\fi
}
\def\I{
 \advance\accumulator by 1
 \checkwrapping
}
\def\D{
 \advance\accumulator by -1
 \checkwrapping
}
\def\S{
 \multiply\accumulator by \accumulator
 \checkwrapping
}
\def\O{
 \message{\the\accumulator}
}
\tracingonline=-1
\scrollmode
\def\Activate{
 \catcode105=13
 \catcode100=13
 \catcode115=13
 \catcode111=13
}
\catcode62=11
\def\Start{
 \escapechar=-1
 \loop
 \read16 to \>>
 \>>
 \iftrue\repeat
}
\Activate
\leti=\I
\letd=\D
\lets=\S
\leto=\O
\Start
== TeXnicard ==
(Note: This is the old version of TeXnicard. The new version is entirely different; it is like a combination of SQL and PostScript, but using the mechanisms like TeX for text rendering rather than those of PostScript.)
To use this program, save it in the file called "deadfish.cards" and then type in "@I deadfish.cards" at the "E>" prompt. And then it change to "C>" prompt and it is ready for typing in commands of deadfish.
<nowiki>
@. Deadfish implementation in TeXnicard.
[d[c0][]dixd256-[][0*][]ix[]]s0
(patterns)sP0
@S i
1+`0x
@S d
1-`0x
@S s
d*`0x
@S o
?s[]
@P patterns
== This=That ==
shell=>> 
flag=1
while loop x=flag~~flag
print shell
input i
if loop a=i~~i
ac=ac plus 1
if loop a=end
if loop b=i~~d
ac=ac minus 1
if loop b=end
if loop c=i~~s
ac=ac times ac
if loop c=end
if loop d=i~~o
print ac
if loop d=end
if loop e=ac<0
ac=0
if loop e=end
if loop f=ac~~256
ac=0
if loop f=end
while loop x=end
== Thue ==
<nowiki>
Deadfish in Thue by Amb ::=
This implementation represents the value in binary. ::=
It does not convert binary to decimal for output. ::=
Fixed to support 256->0 by Oerjan ::=
| ::=|
$<00::=$<0
$<01::=$<1
$<0|::=$0*|
$<11::=$11*
$<1|::=$1*|
$<101::=$101*
$<10|::=$10*|
$<1001::=$1001*
$<100|::=$100*|
$<10001::=$10001*
$<1000|::=$1000*|
$<100001::=$100001*
$<10000|::=$10000*|
$<1000001::=$1000001*
$<100000|::=$100000*|
$<10000001::=$10000001*
$<1000000|::=$1000000*|
$<100000001::=$100000001*
$<10000000|::=$10000000*|
$<1000000000::=$1000000000*
$<1000000001::=$1000000001*
$<100000000|::=$0*|
><::=>*
0<::=<0
1<::=<1
*|i::=i|
*|d::=d|
*|s::=s|
*|o::=o|
*0::=0*
*1::=1*
0i::=<1
1i::=i0
$i::=$<1
1d::=<0
0d::=d1
$d1::=$d
$d|::=$0*|
0o::=o0
1o::=o1
$o::=$*#o
#::=~ 
*o0::=0*[o
[::=~0
*o1::=1*]o
]::=~1
*o|::=*|
0s::=s0
1s::=s1
0-::=-0
0+::=+0
1-::=-1
1+::=+1
$-::=0$
$+::=1$
$s::=$*s
*s0::=-0*s
*s1::=+1*s
*s|::=t|
0t::=t(0)
1t::=t(1)
$t::=$u
$u::=d$
>d1::=>d
>d$::=>$w
*$::=$uv
v(0)::=(0)v
v(1)::=(1)1v
v0::=0v
v1::=1v
v|::=|
w(0)::=%w
w(1)::=%w
w1::=1w
w|::=x|
%x::=x0
%1x::=x1
11x::=yx
1y::=y1
%y::=1%
$y::=$1%
$1x::=$<1
$x::=$<
?::=:::
::=
>$0*|?
</nowiki>
== Thutu ==
This stores data in unary, which explains its inefficiency and the length of one of the lines.
/=>=> =x/z=x/
*
 /=>=> =x/>
 /=1/=n=>=> =xse/
 /^i=xs(a*)e/=>=> =xs$1ae/
 /^d=xsa?(a*?)e/=>=> =xs$1e/
 /^s=xs(a*)a(b*)e/s=xs$1b$2e$1$2b/
 /^s=xs(b*)e(a*)b/s=xs$1e$2a/
 /^s=xs(b*)e(a*)$/=>=> =xs$2e/
 /^o=xs(a*)e$/o=xs$1v/
 /(=x.*[sbc])v/$1w0/
 /(=x.*[sbc])av/$1cw1/
 /(=x.*[sbc])aav/$1ccw2/
 /(=x.*[sbc])aaav/$1cccw3/
 /(=x.*[sbc])aaaav/$1ccccw4/
 /(=x.*[sbc])aaaaav/$1cccccw5/
 /(=x.*[sbc])aaaaaav/$1ccccccw6/
 /(=x.*[sbc])aaaaaaav/$1cccccccw7/
 /(=x.*[sbc])aaaaaaaav/$1ccccccccw8/
 /(=x.*[sbc])aaaaaaaaav/$1cccccccccw9/
 /(=x.*[sbc])aaaaaaaaaa(a*)v/$1bbbbbbbbbb$2v/
 /(=xsc*)bbbbbbbbbb(.*)w/$1ccccccccca$2w/
 /(=x.*)ab(.*w)/$1ba$2/
 /(=x.*)ac(.*w)/$1ca$2/
 /(=x.*)bc(.*w)/$1cb$2/
 /=xs([ca]*)aw/=xs$1av/
 /=xs(c*)w/=xs$1x/
 /=xs(c*)c(a*)x/=xs$1a$2x/
 /^o=xs(a*)x(.*)$/$2=n=>=> =xs$1e/
 /^.*=x/=n=>=> =x/
.
*
 /=xsaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaae/se/
.
== TI-68k ==
deadfish(src)
Prgm
Local acc
0->acc
Loop
Local cmd
left(src,1)->cmd
If acc=256 or acc<0 Then
0->acc
EndIf
If cmd="i" Then
acc+1->acc
ElseIf cmd="d" Then
acc-1->acc
ElseIf cmd="s" Then
acc^2->acc
ElseIf cmd="o" Then
Disp acc
EndIf
If dim(src)=1 or cmd="h" Then
Exit
EndIf
right(src,dim(src)-1)->src
EndLoop
EndPrgm
== TI-BASIC ==
ClrHome
Disp "REGULAR DEADFISH","IDSO INTERPRETER
DelVar AInput Str1 //DelVar doesn't need a colon or newline after its argument; this is the same as "DelVar A:Input Str1"
For(B,1,length(Str1
sub(Str1,B,1
If Ans="O
Disp A
A(not(Ans="S")+A(Ans="S"))+(Ans="I")-(Ans="D
Ans(Ans<256 and Ans->A
End
== Ti-Nspire Basic ==
Note: Since Ti-Nspire Basic doesn't support printing without making a new line, it stores the output then displays it at the end.
Define deadfish(program)=Prgm
 Local program,pos,acc,command,line
 line:=""
 acc:=0
 For pos,1,dim(program)
 command:=Mid(program,pos,1)
 
 If command="i" Then
 acc:=acc + 1
 ElseIf command="d" Then
 acc:=acc - 1
 ElseIf command="s" Then
 acc:=acc2
 ElseIf command="o" Then
 line:=line&char(acc)
 Else
 line:=line&char(13)
 EndIf
 If (acc<0) Or (acc>255) acc:=0
 EndFor
 Disp line
EndPrgm
== Timers ==
~~ call deadfish
,(deadfish~)
~~ display prompt, get input and call process
'>> '{([.:]~)-128(^,~).(@process~)}
~~ process the input
'process'{
 1(;^<!| check256 checkneg default ?)
 1(;^< |~) ~~ exit process
 check256 {(^:#)256(^=!:|`~)256($$~)}
 checkneg {(^:#)2(^).(^\/<!:|`~).($$~)}
 default {(:[?]~)'idos'($~)-($"~)}
 i {(^:#)1(^+`~)}
 d {(^:#)1(^-`~)}
 o {(^#."~)}
 s {(^:#)?(^*`~)}
}
~~ setting up deadfish
deadfish {
 0(^loop) ~~ set initial value
 loop{('>> ')} ~~ loop prompt
}
== Tosh ==
when flag clicked
delete all of Console
set accumulator to 0
set Read to 0
ask Code: and wait
repeat until <Read > (length of answer)>
	if <(letter Read of answer) = 'i'> or <(letter Read of answer) = 'x'> then
		change accumulator by 1
	end
	if <(letter Read of answer) = 'd'> then
		change accumulator by -1
	end
	if <<(letter Read of answer) = 's'> or <(letter Read of answer) = 'k'>> then
		set accumulator to (accumulator * accumulator)
	end
	if <<(letter Read of answer) = 'o'> or <(letter Read of answer) = 'c'>> then
		add accumulator to Console
	end
	if <<(accumulator) < 0> or <(accumulator) = 256>> then
		set accumulator to 0
	end
	change Read by 1
end
== Trampolines ==
| \ #
| H============H #
| ^ H #
| ^ H #
| } H #
| 1 H^^ H #
| !< 0 H #
| \ > H H #
| H==H H H #
| ^ / H H #
| 2 H H #
| 5 H H #
| @ H H #
| 6 H^^ H H #
|o@< 0H H #
|0\ > H H #
|{H==H H H #
|1^ / H H #
|!H======H H #
|,{ / H #
|=H H #
| 1 ^ H #
| !> H H #
| \ # H #
| 1 H #
| 0 H #
| @ H #
| 5 H}1 H #
| @< + H #
| \ > { H #
| H==H -H #
| ^ / H #
| 1 H #
| 0 H #
| @ H\ #
| 0 H}1 HH #
| @< ! -H #
| \ > + H #
| H==H { H #
| ^ / -H #
| 1 /H #
| 1 HH #
| @ H- #
| 5 H}~ H #
| @< * H #
| \ > { H #
| H==H -H #
| ^ / H #
| 1 H #
| 1 H #
| @ H #
| 1 H}~ H #
| @< ; H #
| \ > { H #
| H==H -H #
| ^ / H #
| 1 H #
| 0 H #
| @ H #
| 4 H# H #
| @< H #
| \ > H #
| H==H H #
| ~ / H #
| H========H #
| \ - #
== Turing ==
% Deadfish in Turing
% Implemented by Chris Pressey on August 4 2012,
% in the Deadfish Cafe in Winnipeg, Manitoba, Canada
% (Thus, this is also "Deadfish in Deadfish")
var accumulator : int
var command : string (1)
accumulator := 0
loop
 if accumulator = 256 or accumulator < 0 then
	accumulator := 0
 end if
 put ">> " ..
 get command
 if command = "i" then
	accumulator := accumulator + 1
 elsif command = "d" then
	accumulator := accumulator - 1
 elsif command = "s" then
	accumulator := accumulator * accumulator
 elsif command = "o" then
	put accumulator
 else
	put "Unrecognized command."
 end if
end loop
== Uiua ==
# Experimental!
quote(⊂ : "0" /⊂⇌ ≡(⊂ "⌵(×≠256.×≠¯1.)" ⟨"+1 "|"-1 "|"×. "|"⟜&p"⟩)⊗:"idso" &sc)
== Umka ==
This version has three main changes from the previous Umka (0.6) version: slightly shortened names, a small for...in syntax change so that the code works in Umka 1.2, and an (optional) default statement inside the switch to explicitly report unrecognized commands.
// Deadfish in Umka (1.2), version 2 -- dnm 2022-02-17, 2023-10-16
import "std.um"
var acc: int = 0
fn getIn(): str {
 s := ""
 for true {
 c := std.getchar()
 if c == '\n' { break }
 s += c
 }
 return s
}
fn main() {
 for true { 
 printf(">> ")
 input := getIn()
 for i, cmd in input {
 switch cmd {
 case 'i': acc++
 case 'd': acc--
 case 's': acc = acc * acc
 case 'o': printf("%i\n", acc)
 default : printf("Unrecognized command\n")
 }
 if acc == 256 || acc < 0 { acc = 0 }
 }
 }
}
== Unlambda ==
This implementation uses Church numerals, which are essentially unary. Use large ones at your own risk.
````sii
 ``s``s`ks ``s``s`kskk
 `k ``s``s `d`k `````.>.>. @ic
 `k ``s``s``s``s`k?i`kii`k ``s``s`ks ``s`k`s`ks ``s`k`s`kk i `ki
 ``s``s``s``s`k?d`kii`k
 ``s``s``si
 `k ``s``s`ks ``s`k`si
 ``s`kk ``s``s`ks ``s`k`s`ks ``s`k`s`kk ``si`kk `ki
 ``s`kk ``si`kk
 `k`k`ki `k`ki
 ``s``s``s``s`k?o`kii`k
 ``sk ``s`kr ``s`k
 ```sii ``s `k `s``s``si
 `k ``s``s``si`kk
 ``s`k`s``si`k
 `k``si`k `k``si`k `k``si`k `k``si`k `k``si`k
 `k``si`k `k``si`k `k``si`k `k``si`k k
 ``s`kk ``s``s`ks``s`k`s`ks ``s`k`s`kk ``si`k`ki `ki
 ``s`k`s``s`ks``s`k`sik ``s`kk``s`kk``si`k`ki
 `ki ``s`kk
 ``s``s`ks ``s`k`s`ks ``s`k`s`kk
 `k ``s``si`k.9 `k ``s``si`k.8 `k ``s``si`k.7 `k ``s``si`k.6 `k
 ``s``si`k.5 `k ``s``si`k.4 `k ``s``si`k.3 `k ``s``si`k.2 `k
 ``s``si`k.1 `k `k.0
 ``s`kk
 ``s``s`ks``s``s`ks
 `k ``s`kc ``s`k`s`k`k`ki ``s``s`ks``s``s`ksk `k`k``si`ki `kk
 ``s``s`kskk `ki
 ``s `k`s``s`ks k i
 ``s``s``s``s`k?s`kii`k ``s``s`ks k i
 ``si`kr
 ``s``s`kc
 ``s`k`s`k`ki
 ``s``s`ks ``s``s`ks ``s``s`ks k `k``s`k`sik
 `k `k ``````s``s`ks k ``s``s`ks k i
 ``s``s`ks k i ``s``s`ks k i
 k ``si`ki
 `k ``s`kd ``si `k`k`ki
 i
 `ki
== Unofficial MagicKit Assembler ===
This is probably the longest one (due to so many things that aren't built-in, so it has to implement all of them). Note, it contains tabs which are necessary to compile properly. You can download the compiled file, source codes, and ".NES.INI" in the external resources section.
To use, push a key "I", "D", "S", or "O" at the prompt. A line break is automatically added after each command; all keys other than "I", "D", "S" and "O" (including the DELETE and RETURN key) are ignored; all buttons on both gamepads are also ignored, and so is the microphone. (If you want to restart the program, push the RESET button on the console.)
; Deadfish implementation for Nintendo Famicom
	inesprg 1 ; 16K PRG ROM
	ineschr 1 ; 8K CHR ROM
	inesmir 1 ; vertical mirroring
	inesmap 0 ; NROM
	zp
digits	ds 8
spare	ds 1
scroll1	ds 1
scroll2	ds 1
blink1	ds 1
blink2	ds 1
csrlin	ds 1
temp2	ds 1
temp3	ds 1
temp4	ds 1
multacc	ds 17
	code
	bank 0
	; Sprites
	org $C000
oamdata	db 215,16,0,32 ; Cursor
	db 223,15,0,$08, 223,15,0,$10, 223,15,0,$18, 223,15,0,$20 ; First hidden row
	db 223,15,0,$28, 223,15,0,$30, 223,15,0,$38, 223,15,0,$40
	db 231,15,0,$08, 231,15,0,$10, 231,15,0,$18, 231,15,0,$20 ; Second hidden row
	db 231,15,0,$28, 231,15,0,$30, 231,15,0,$38, 231,15,0,$40
	; Multiplication table
	org $C100
muones	db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
	db 0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5
	db 0,2,4,6,8,0,2,4,6,8,0,2,4,6,8,0
	db 0,3,6,9,2,5,8,1,4,7,0,3,6,9,2,5
	db 0,4,8,2,6,0,4,8,2,6,0,4,8,2,6,0
	db 0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5
	db 0,6,2,8,4,0,6,2,8,4,0,6,2,8,4,0
	db 0,7,4,1,8,5,2,9,6,3,0,7,4,1,8,5
	db 0,8,6,4,2,0,8,6,4,2,0,8,6,4,2,0
	db 0,9,8,7,6,5,4,3,2,1,0,9,8,7,6,5
mutens	db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ;0
	db 0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1 ;1
	db 0,0,0,0,0,1,1,1,1,1,2,2,2,2,2,3 ;2
	db 0,0,0,0,1,1,1,2,2,2,3,3,3,3,4,4 ;3
	db 0,0,0,1,1,2,2,2,3,3,4,4,4,5,5,6 ;4
	db 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7 ;5
	db 0,0,1,1,2,3,3,4,4,5,6,6,7,8,9,9 ;6
	db 0,0,1,2,2,3,4,4,5,6,7,7,8,9,9,0 ;7
	db 0,0,1,2,3,4,4,5,6,7,8,8,9,0,1,2 ;8
	db 0,0,1,2,3,4,5,6,7,8,9,9,0,1,2,3 ;9
	;; 0 1 2 3 4 5 6 7 8 9 A B C D E F
	; Addition table
adones	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
	db 0,1,2,3,4,5,6,7,8,9
adtens	db 0,0,0,0,0,0,0,0,0,0
	db 1,1,1,1,1,1,1,1,1,1
	db 2,2,2,2,2,2,2,2,2,2
	db 3,3,3,3,3,3,3,3,3,3
	db 4,4,4,4,4,4,4,4,4,4
	db 5,5,5,5,5,5,5,5,5,5
	db 6,6,6,6,6,6,6,6,6,6
	db 7,7,7,7,7,7,7,7,7,7
	db 8,8,8,8,8,8,8,8,8,8
	db 9,9,9,9,9,9,9,9,9,9
	; =256 table
eq256	db 6,5,2,0,0,0,0,0
	bank 1
	org $E000
	; Initialize APU/PPU/CPU
reset	sei
	ldx #$FF
	txs
	inx
	stx $2000
	stx $4015
	bit $2002 ; Clear VBL
vwait1	bit $2002
	bpl vwait1
vwait2	bit $2002
	bpl vwait2
	stx $2000
	stx $2001 ; Disable PPU
	; Initialize RAM
	ldy #csrlin
initram	stx <0,y
	dey
	bpl initram
	lda #216
	sta <scroll2
	; Initialize palette
	lda #$3F
	sta $2006
	stx $2006
	ldy #$0A
initpal	sta $2007
	stx $2007
	dey
	bne initpal
	; Clear screen
	lda #$20
	sta $2006
	stx $2006
	lda #$0F
clrscr	sta $2007
	sta $2007
	sta $2007
	sta $2007
	dex
	bne clrscr
	; Display prompt
prompt	ldx #$00
	stx $2000
	stx $2001
	jsr newline
	lda #$0A
	sta $2007
	sta $2007
	lda #$0F
	sta $2007
	sta $2007
	sta $2007
	sta $2007
	sta $2007
	sta $2007
	lda #$80
	sta $2000
	; Wait until all keys are not pushed
keywait	lda #8
	sta <csrlin
	ldy #$05
	ldx #$04
	sty $4016
	iny
keyw1	stx $4016
	lda $4017
	and #$1E
	eor #$1E
	bne keywait
	sty $4016
	lda $4017
	and #$1E
	eor #$1E
	bne keywait
	dec <csrlin
	bne keyw1
	; Read keyboard
keyloop ldy #$05
	ldx #$04
	sty $4016
	iny
	stx $4016
	sty $4016
	stx $4016 ; Skip row 0
	sty $4016
	stx $4016 ; Skip row 1
	lda $4017
	and #$04
	beq keyo
	sty $4016
	stx $4016 ; Skip row 2
	lda $4017
	and #$04
	beq keyi
	sty $4016
	stx $4016 ; Skip row 3
	sty $4016
	stx $4016 ; Skip row 4
	lda $4017
	and #$10
	beq keyd
	sty $4016
	stx $4016 ; Skip row 5
	lda $4017
	and #$08
	beq keys
	jmp keyloop
keyo	lda #$0E
	jsr letter
	jmp cmdo
keyi	lda #$0B
	jsr letter
	jmp cmdi
keyd	lda #$0C
	jsr letter
	jmp cmdd
keys	lda #$0D
	jsr letter
	jmp cmds
	; Output
cmdo	jsr newline
	lda #$0F
	sta <csrlin
	ldy #7
out1	lda 0,y
	cpy #0
	beq out2
	cmp #0
	beq out3
out2	stx <csrlin
out3	eor <csrlin
	sta $2007 
	dey
	bpl out1
	jmp prompt
	; Increment
cmdi	stx <spare ; Clear guard digit
incr1	inc <0,x
	lda <0,x
	cmp #10
	bne chk256
	lda #0
	sta <0,x
	inx
	bne incr1
chk256	ldx #0
incr2	lda <0,x
	cmp eq256,x
	bne incr3 ; It isn't "256"
	inx
	cpx #8
	bne incr2
	sta <0
	sta <1
	sta <2
incr3	jmp prompt
	; Decrement
cmdd	lda <0,x
	bne decr1
	inx
	cpx #$08
	bne cmdd
	jmp prompt ; It is already zero
decr1	ldx #$00
decr2	lda <0,x
	beq decr3
	dec <0,x
	jmp chk256 ; Now check if equal to 256
decr3	lda #9
	sta <0,x
	inx
	bne decr2
	; Square
cmds	stx <spare ; Clear guard digit
	ldy #16
squ1	stx <multacc,y ; Clear multiplication accumulator memory
	dey
	bpl squ1
	ldy #7
squ2	ldx #7
squ3	lda <0,x
	sta <csrlin
	lda 0,y
	asl a
	asl a
	asl a
	asl a
	eor <csrlin
	sty <csrlin
	tay
	lda muones,y
	sta <temp2 ; Ones digit
	lda mutens,y
	sta <temp4 ; Tens digit
	stx <temp3
	lda <csrlin ; Position of a digit
	clc
	adc <temp3 ; Position of another digit
	tay
	lda <temp2
	adc multacc,y
	sta multacc,y
	lda <temp4
	clc
	adc multacc+1,y
	sta multacc+1,y
	ldy <csrlin
	dex
	bpl squ3
	dey
	bpl squ2
	; Now conversion into base ten proper digits
	inx
	stx <temp2 ; Carry
squ4	lda <multacc,x
	clc
	adc <temp2
	tay
	lda adones,y
	sta <0,x
	lda adtens,y
	sta <temp2
	inx
	cpx #8
	bne squ4
	jmp chk256 ; Check if equal to 256
	; New line routine (expects X=0)
newline	lda <scroll1
	clc
	adc #8
	cmp #240
	bne nscrz1
	txa
nscrz1	sta <scroll1
	lda <scroll2
	clc
	adc #8
	cmp #240
	bne nscrz2
	txa
nscrz2	sta <scroll2
	ldy #$08
	sty <csrlin
	asl a
	rol <csrlin
	asl a
	rol <csrlin
	ldy <csrlin
	sty $2006
	ora #$01
	sta $2006
	rts
	; Write letter to screen (A=letter to write)
letter	pha
	ldx #$00
	stx $2000
	stx $2001
	lda <scroll2
	jsr nscrz2
	lda #$0A
	sta $2007
	sta $2007
	lda #$0F
	sta $2007
	pla
	sta $2007
	rts
	; NMI handler
nmi	pha
	; Reset latch
	bit $2002
	; Cursor blink
	lda #$3F
	sta $2006
	lda #$13
	sta $2006
	inc <blink1
	cmp <blink1
	bne noblink
	lda <blink2
	eor #$1D
	sta $2007
	sta <blink2
	lda #$00
	sta <blink1
	; Scroll
noblink	lda #$00
	sta $2006
	sta $2006
	sta $2005
	lda <scroll1
	sta $2005
	; OAM
	lda #$C0
	sta $4014
	; Enable rendering
	lda #$1E
	sta $2001
	; Done
	pla
	rti
	; Vectors
	org $FFFA
	dw nmi,reset,0
	; Pattern table
	bank 2
	org $0000
	;0
	defchr $00011100,\
	 $00100110,\
	 $01100011,\
	 $01100011,\
	 $01100011,\
	 $00110010,\
	 $00011100,\
	 $00000000
	;1
	defchr $00001100,\
	 $00011100,\
	 $00001100,\
	 $00001100,\
	 $00001100,\
	 $00001100,\
	 $00111111,\
	 $00000000
	;2
	defchr $00111110,\
	 $01100011,\
	 $00000111,\
	 $00011110,\
	 $00111100,\
	 $01110000,\
	 $01111111,\
	 $00000000
	;3
	defchr $00111111,\
	 $00000110,\
	 $00001100,\
	 $00011110,\
	 $00000011,\
	 $01100011,\
	 $00111110,\
	 $00000000
	;4
	defchr $00001110,\
	 $00011110,\
	 $00110110,\
	 $01100110,\
	 $01111111,\
	 $00000110,\
	 $00000110,\
	 $00000000
	;5
	defchr $01111110,\
	 $01100000,\
	 $01111110,\
	 $00000011,\
	 $00000011,\
	 $01100011,\
	 $00111110,\
	 $00000000
	;6
	defchr $00011110,\
	 $00110000,\
	 $01100000,\
	 $01111110,\
	 $01100011,\
	 $01100011,\
	 $00111110,\
	 $00000000
	;7
	defchr $01111111,\
	 $01100011,\
	 $00000110,\
	 $00001100,\
	 $00011000,\
	 $00011000,\
	 $00011000,\
	 $00000000
	;8
	defchr $00111100,\
	 $01100010,\
	 $01110010,\
	 $00111100,\
	 $01001111,\
	 $01000011,\
	 $00111110,\
	 $00000000
	;9
	defchr $00111110,\
	 $01100011,\
	 $01100011,\
	 $00111111,\
	 $00000011,\
	 $00000110,\
	 $00111100,\
	 $00000000
	;>
	defchr $00110000,\
	 $00011000,\
	 $00001100,\
	 $00000110,\
	 $00001100,\
	 $00011000,\
	 $00110000,\
	 $00000000
	;I
	defchr $01111110,\
	 $00011000,\
	 $00011000,\
	 $00011000,\
	 $00011000,\
	 $00011000,\
	 $01111110,\
	 $00000000
	;D
	defchr $01111100,\
	 $01100110,\
	 $01100011,\
	 $01100011,\
	 $01100011,\
	 $01100110,\
	 $01111100,\
	 $00000000
	;S
	defchr $00111110,\
	 $01100011,\
	 $01100000,\
	 $00111110,\
	 $00000011,\
	 $01100011,\
	 $00111110,\
	 $00000000
	;O
	defchr $00111110,\
	 $01100011,\
	 $01100011,\
	 $01100011,\
	 $01100011,\
	 $01100011,\
	 $00111110,\
	 $00000000
	;blank
	defchr $22222222,\
	 $22222222,\
	 $22222222,\
	 $22222222,\
	 $22222222,\
	 $22222222,\
	 $22222222,\
	 $22222222
	;cursor
	defchr $00000000,\
	 $00303030,\
	 $00030300,\
	 $00303030,\
	 $00030300,\
	 $00303030,\
	 $00000000,\
	 $00000000
== Uxn ==
 \\ Deadfish in Uxn
 \\ (use in non-GUI mode)
 
 |0100
 #0000 STH2k
 [; #10 DEO2 BRK ]@
 
 \\ Change 256 to 0
 DUP2 #0100 NEQ2
 [? POP2 STH2rk ]@
 
 \\ Check input
 #12 DEI
 DUP LIT "i EQU ,i JCN
 DUP LIT "d EQU ,d JCN
 DUP LIT "s EQU ,s JCN
 LIT "o EQU ,o JCN BRK
 
 @i
 POP INC2 BRK
 
 @d
 POP ORAk STHrk NEQk ROT POP SUB2 BRK
 
 @s
 POP DUP2 MUL2 BRK
 
 @o
 DUP2
 [@
 #000a DIV2k STH2k MUL2 SUB2
 STH2 SWP2r STH2r
 NIPr LITr 30 ADDr
 ORAk ]?
 POP2
 [@ LITr 18 DEOr STHrk ]?
 #0a18 DEO BRK
Hex dump:
 a0 00 00 af a0 01 0b 80 10 37 00 26 a0 01 00 29
 20 00 02 22 ef 80 12 16 06 80 69 08 80 15 0d 06
 80 64 08 80 11 0d 06 80 73 08 80 12 0d 80 6f 08
 80 10 0d 00 02 21 00 02 9d cf 89 05 02 39 00 02
 26 3a 00 26 a0 00 0a bb af 3a 39 2f 64 6f 43 c0
 30 58 9d 20 ff ee 22 c0 18 57 cf 20 ff f9 a0 0a
 18 17 00 
== Uyjhmn n ==
DECLARE THE NEW VARIABLE x
OPEN THE VARIABLE x
ASSIGN 0 TO THE OPEN VARIABLE
DECLARE THE NEW VARIABLE i
OPEN THE VARIABLE i
ASSIGN 105 TO THE OPEN VARIABLE
DECLARE THE NEW VARIABLE d
OPEN THE VARIABLE d
ASSIGN 100 TO THE OPEN VARIABLE
DECLARE THE NEW VARIABLE s
OPEN THE VARIABLE s
ASSIGN 115 TO THE OPEN VARIABLE
DECLARE THE NEW VARIABLE o
OPEN THE VARIABLE o
ASSIGN 111 TO THE OPEN VARIABLE
DECLARE THE NEW VARIABLE one
OPEN THE VARIABLE one
ASSIGN 1 TO THE OPEN VARIABLE
DECLARE THE NEW VARIABLE minusone
OPEN THE VARIABLE minusone
ASSIGN -1 TO THE OPEN VARIABLE
DECLARE THE NEW VARIABLE twohundredfiftysix
OPEN THE VARIABLE twohundredfiftysix
ASSIGN 256 TO THE OPEN VARIABLE
DECLARE THE NEW VARIABLE cmd
DEFINE THE NEW LABEL main
OPEN THE VARIABLE x
JUMP TO nottwohundredfiftysix IF x IS GREATER THAN twohundredfiftysix
JUMP TO nottwohundredfiftysix IF x IS LESS THAN twohundredfiftysix
ASSIGN 0 TO THE OPEN VARIABLE
DEFINE THE NEW LABEL nottwohundredfiftysix
JUMP TO notminusone IF x IS GREATER THAN minusone
ASSIGN 0 TO THE OPEN VARIABLE
DEFINE THE NEW LABEL notminusone
PRINT THE CHARACTER WITH THE ASCII VALUE 62
PRINT THE CHARACTER WITH THE ASCII VALUE 62
PRINT THE CHARACTER WITH THE ASCII VALUE 32
OPEN THE VARIABLE cmd
GET INPUT AND STORE INTO OPEN VARIABLE AS A CHARACTER
JUMP TO increment IF cmd IS EQUAL TO i
JUMP TO decrement IF cmd IS EQUAL TO d
JUMP TO square IF cmd IS EQUAL TO s
JUMP TO output IF cmd IS EQUAL TO o
PRINT THE CHARACTER WITH THE ASCII VALUE 10
JUMP TO main if x IS EQUAL TO x
DEFINE THE NEW LABEL increment
OPEN THE VARIABLE x
ADD one TO THE OPEN VARIABLE
JUMP TO main IF x IS EQUAL TO x
DEFINE THE NEW LABEL decrement
OPEN THE VARIABLE x
ADD minusone TO THE OPEN VARIABLE
JUMP TO main IF x IS EQUAL TO x
DEFINE THE NEW LABEL square
OPEN THE VARIABLE x
MULTIPLY THE OPEN VARIABLE BY x
JUMP TO main IF x IS EQUAL TO x
DEFINE THE NEW LABEL output
OPEN THE VARIABLE x
PRINT THE OPEN VARIABLE'S VALUE
PRINT THE CHARACTER WITH THE ASCII VALUE 10
JUMP TO main IF x IS EQUAL TO x
== V3i ==
def x 0;
iloop if input = o;
print x;
else if input = i;
def x x+1;
else if input = d;
def x x-1;
else if input = s;
def x x*x;
else; print "Invalid command";
== var'aq ==
Notes:
Will only allow one command per line
Can only be stopped by killing the process
The way var'aq is currently implemented (interpreter-wise), any program using 'lj will not run correctly unless the code is copied into the command-line directly
(* QopghotI' mughwI' var'aq *)
0 "toD" cher
~ QopghotI'mughwI' {
 ">> " cha'
 'Ij "Doch" cher
 Doch 0 1 tlheghpe' "Doch" cher
 Doch "i" tlheghrap'a' { toD 1 boq "toD" cher } HIja'chugh
 Doch "d" tlheghrap'a' { toD 1 boqHa' "toD" cher } HIja'chugh
 Doch "o" tlheghrap'a' { toD cha' } HIja'chugh
 Doch "s" tlheghrap'a' { toD toD boq'egh "toD" cher } HIja'chugh
 toD -1 rap'a' { 0 "toD" cher } HIja'chugh
 toD 256 rap'a' { 0 "toD" cher } HIja'chugh
 QopghotI'mughwI'
} pong
 QopghotI'mughwI'
== WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++ ==
See WeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeBasic++#Deadfish.
== Visual Basic .NET ==
Implementation by User:David.werecat which allows a program file to be specified as a command line parameter.
 Option Explicit On
 Option Strict On
 Module Deadfish
 	Dim Val As Integer = 0
 	Sub Main()
 		Dim ProgCode As String = ""
 		Try : ProgCode = My.Computer.FileSystem.ReadAllText(Command().Trim(""""c))
 		Catch : End Try
 		For Each C As Char In ProgCode
 			Interpret(C)
 		Next
 		While True
 			Console.Write(">> ") : Interpret(Console.ReadKey.KeyChar)
 		End While
 	End Sub
 	Sub Interpret(ByVal C As Char)
 		Select Case C
 			Case "d"c : Val -= 1 : Console.WriteLine()
 			Case "i"c : Val += 1 : Console.WriteLine()
 			Case "o"c : Console.WriteLine() : Console.WriteLine(Val.ToString())
 			Case "s"c : Val = Val ^ 2 : Console.WriteLine()
 		End Select
 		If (Val < 0) Or (Val = 256) Then Val = 0
 	End Sub
 End Module
== Vorpal ==
 method() {
 acc = 0
 while (1 > 0) {
 input = '>> '.input()
 if ((acc == 256) || (acc < 0)) {
 acc = 0
 }
 if (input == "i") {
 acc = acc + 1
 } else {
 if (input == "d") {
 acc = acc - 1
 } else {
 if (input == "s") {
 acc = acc * acc
 } else {
 if (input == "o") { 
 acc.print()
 }
 }
 }
 }
 }
 }
== WARP ==
 +A@s,l=li!:li:0?0?^.p%li@m}pc>pc1^_m|^.s@p=espc=pc0@r{pc=cc!
 :"i":cc?0?>xx1:"d":cc?0?<xx1:"s":cc?0?&xxxx:"o":cc?0?)xx
 :256:xx?0?=xx0:es:pc?0?^.e>pc1^.r@e
== Wenyan ==
吾有一術。名之曰「死魚」。欲行是術。必先得一言。曰「代碼」。
乃行是術曰。
	有數零。名之曰「纍加器」。
	凡「代碼」中之「字」。
		若「字」等於「「i」」者。
			加「纍加器」以一。昔之「纍加器」者。今其是矣。
		云云。
		若「字」等於「「d」」者。
			減「纍加器」以一。昔之「纍加器」者。今其是矣。
		云云。
		若「字」等於「「s」」者。
			乘「纍加器」以「纍加器」。昔之「纍加器」者。今其是矣。
		云云。
		若「字」等於「「o」」者。
			吾有一言。曰「纍加器」。書之。
		云云。
		若「纍加器」等於二百五十六者。
			昔之「纍加器」者。今零是矣。
		云云。
		若「纍加器」等於負一者。
			昔之「纍加器」者。今零是矣。
		云云。
	云云。
是謂「死魚」之術也。
注曰「「問天地好在（數字）」」。
施「死魚」於「「iiisdsiiiiiiiioiiiiiiiiiiiiiiiiiiiiiiiiiiiiioiiiiiiiooiiiodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoddddddddddddodddddddddddddddddddddsddoddddddddoiiioddddddoddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo」」。
吾有一言。曰「「========================」」。書之。
注曰「「XKCD隨機數」」。
施「死魚」於「「iiso」」。
吾有一言。曰「「========================」」。書之。
注曰「「必要測試」」。
施「死魚」於「「iissso」」。注曰「「零」」。
施「死魚」於「「diissisdo」」。注曰「「二百八十八」」。
施「死魚」於「「iissisdddddddddddddddddddddddddddddddddo」」。注曰「「零」」。
by User:None1.
== Whitespace ==
The first is with syntax highlighting, the second is a hexdump for recreating as the wiki software really can't cope.
    
   
         
 
  
   
           
 
   
             
    
    
 
     
    
    
    
    
 
      
    
           
    
     
 
           
    
     
 
           
    
     
 
           
    
      
 
       
 
  
 
 
    
 
    
 
  
     
 
    
    
 
 
     
 
    
    
 
 
     
 
 
    
 
 
      
 
 
  
         
 
  
 
 
 000000: 20 20 20 20 0a 0a 20 20 09 0a 20 20 20 09 09 09 ␊␊ ␉␊ ␉␉␉
 000010: 09 09 20 0a 20 0a 20 09 0a 20 20 09 0a 20 20 20 ␉␉ ␊ ␊ ␉␊ ␉␊
 000020: 20 20 09 20 20 20 20 20 0a 09 0a 20 20 20 0a 20 ␉ ␊␉␊ ␊
 000030: 20 20 20 09 20 20 20 20 20 20 20 20 0a 09 20 20 ␉ ␊␉
 000040: 09 0a 09 20 09 20 0a 20 0a 20 20 20 09 09 0a 09 ␉␊␉ ␉ ␊ ␊ ␉␉␊␉
 000050: 20 20 09 0a 09 20 09 20 0a 0a 20 20 09 09 0a 20 ␉␊␉ ␉ ␊␊ ␉␉␊
 000060: 20 20 20 0a 09 0a 09 20 20 20 20 20 0a 09 09 09 ␊␉␊␉ ␊␉␉␉
 000070: 20 0a 20 20 20 20 09 09 20 09 20 20 09 0a 09 20 ␊ ␉␉ ␉ ␉␊␉
 000080: 20 09 0a 09 20 09 20 09 0a 20 0a 20 20 20 20 09 ␉␊␉ ␉ ␉␊ ␊ ␉
 000090: 09 20 20 09 20 20 0a 09 20 20 09 0a 09 20 09 09 ␉ ␉ ␊␉ ␉␊␉ ␉␉
 0000a0: 20 0a 20 0a 20 20 20 20 09 09 09 20 20 09 09 0a ␊ ␊ ␉␉␉ ␉␉␊
 0000b0: 09 20 20 09 0a 09 20 09 09 09 0a 20 0a 20 20 20 ␉ ␉␊␉ ␉␉␉␊ ␊
 0000c0: 20 09 09 20 09 09 09 09 0a 09 20 20 09 0a 09 20 ␉␉ ␉␉␉␉␊␉ ␉␊␉
 0000d0: 09 20 20 20 0a 20 0a 0a 20 20 20 09 20 09 20 0a ␉ ␊ ␊␊ ␉ ␉ ␊
 0000e0: 09 0a 20 20 0a 20 0a 09 0a 0a 20 20 09 20 0a 20 ␉␊ ␊ ␊␉␊␊ ␉ ␊
 0000f0: 0a 0a 20 20 20 20 0a 0a 20 0a 09 09 0a 0a 20 20 ␊␊ ␊␊ ␊␉␉␊␊
 000100: 09 20 09 0a 20 0a 0a 20 20 20 09 0a 09 20 20 20 ␉ ␉␊ ␊␊ ␉␊␉
 000110: 0a 20 0a 09 0a 0a 20 20 09 09 20 0a 20 0a 0a 20 ␊ ␊␉␊␊ ␉␉ ␊ ␊␊
 000120: 20 09 09 0a 09 20 20 20 0a 20 0a 09 0a 0a 20 20 ␉␉␊␉ ␊ ␊␉␊␊
 000130: 09 09 09 0a 20 0a 0a 20 0a 20 09 20 20 0a 0a 20 ␉␉␉␊ ␊␊ ␊ ␉ ␊␊
 000140: 0a 09 0a 0a 20 20 09 20 20 20 0a 20 0a 0a 20 0a ␊␉␊␊ ␉ ␊ ␊␊ ␊
 000150: 20 09 0a 20 09 20 20 20 09 20 09 20 0a 09 0a 20 ␉␊ ␉ ␉ ␉ ␊␉␊
 000160: 20 0a 20 0a 09 0a 0a 0a 0a ␊ ␊␉␊␊␊␊
== WTFZOMFG ==
 '>> "
 _2 + 
 ( 
 _0 %4 _4 ~-256 | { _0 =0 } _3
 > +
 > > ^
 & > @i | { _0 + _3 } <
 & > @d | { _0 - _3 } <
 & > @s | { _0 & m _3 } < 
 & > @o | { _0 \ '\n" _3 } <
 & > ~-10 | { '>> " } <
 +
 )
== XPL0 ==
Tested and works with EXPL (a.k.a. EXPL-32) on Windows, "legacy" 16-bit integer XPL0 on DOS (DOSBox), and 32-bit integer XPL0 (with XPLPX optimizing compiler) on DOS (DOSBox). Not yet tested with the 32-bit XPL0 versions on Raspberry Pi (XPLR/XPL0).
\ Deadfish in XPL0, version 2 -- dnm 2022-04-05, 2022-04-11, 2022-04-12
\ Thanks & greetz to: Loren Blaney (Boreal/6502) and Larry Fish
\ Uncomment the next line if using 16-bit XPL0 (not XPLPX/XPLP, EXPL, XPLR/XPL0)
\\include C:\CXPL\CODESI.XPL;
int Acc, Cmd;
[
 Acc:= 0;
 loop
 [
 Text(0, ">> ");
 Cmd:= ChIn(1);
 ChOut(0, Cmd);
 case Cmd of
 ^i: Acc:= Acc + 1;
 ^d: Acc:= Acc - 1;
 ^s: Acc:= Acc * Acc;
 ^o: [CrLf(0); IntOut(0, Acc)]
 other [CrLf(0); Text(0, "Unrecognized command")];
 CrLf(0);
 if Acc = 256 ! Acc < 0 then
 Acc:= 0;
 ]
]
== Zeno ==
% Deadfish in Zeno (nearly a copy of Deadfish in Turing) -- dnm 2021-05-08
var accumulator : int := 0
var command : string
program
while true
 if (accumulator = 256) or (accumulator < 0) then
 accumulator := 0
 end if
 get command % Uses Zeno's default Output window "? " prompt vs. ">> "
 if command = "i" then
 accumulator := accumulator + 1
 elsif command = "d" then
 accumulator := accumulator -1
 elsif command = "s" then
 accumulator := accumulator * accumulator
 elsif command = "o" then
 put accumulator
 else
 put "Unrecognized command."
 end if
end while
end program
== ZiziQue ==
 [Start]
 !i^inc"Increment
 !d^dec"Decrement
 !s^sqr"Square
 !o^out"Output
 .
 [out]
 "{number}
 ^Start
 [inc]
 +number
 ^Start
 [dec]
 -number
 ^Start
 [sqr]
 =number,{{number}*{number}}
 ^Start
== ZZ Zero ==
 * Deadfish in ZZ Zero
 
 !INIT G,0
 !INIT H,0
 
 !KIND $00
 !NAME EMPTY
 !FLAG $0000
 !APP $020
 
 !KIND $01
 !NAME MAIN
 !FLAG $0020
 !APP \>
 
 !UPD @
 EQ H,256
 TLET H,G
 JZ D,-1
 TONE A,-200
 EQ D,\I
 JT D,II
 EQ D,\D
 JT D,DD
 EQ D,\S
 JT D,SS
 EQ D,\O
 JT D,OO
 END A,A
 
 II INC H,H
 END H,H
 
 DD JZ H,-1
 DEC H,H
 END H,H
 
 SS MUL H,H
 END H,H
 
 OO TEXT A,G
 APND A,H
 END H,H
 
 !END
Create a board containing a single piece of kind MAIN with speed 1.
Category:Implementations