nyuuzyou/wikis huggingface dataset:
SQD

SQD (Stack, Queue and Deque) is an esolang by User:ChuckEsoteric08.
==Specification==
SQD uses Stack, Queue and Dequeue as memory.
Commands for Stack:
 number from 0 to 9 followed by 0 - push number from 0 to 9 to the stack.
 +, -, * or / followed by 0 - pop a and b and push b<op>a.
 ?0 - pop and declare label with popped element as its name.
 =0[...] - pop a and b and if they are equal execute code inside the brackets.
 >0[...] - pop a and b and if they b>a equal execute code inside the brackets.
 <0[...] - pop a and b and if they b>a equal execute code inside the brackets.
 "0 - pop element and goto label which names is equal to popped value.
 :0 - duplicate top element.
 ;0 - pop a and b then push b a times.
Commands for Queue:
 number from 0 to 9 followed by 1 - enqueue number from 0 to 9.
 +, -, * or / followed by 1 - dequeue a and b and enqueue a<op>b.
 ?1 - dequeue and declare label with dequeued element as its name.
 =1[...] - dequeue a and b and if they are equal execute code inside the brackets.
 >1[...] - dequeue a and b and if they a>b equal execute code inside the brackets.
 <1[...] - dequeue a and b and if they a>b equal execute code inside the brackets.
 "1 - dequeue element and goto label which names is equal to dequeued value.
 :1 - duplicate bottom element.
 ;1 - dequeue a and b then enqueue a b times.
Commands for Dequeue:
 number from 0 to 9 followed by 20 - push digit x to the top
 +, -, * or / followed by 20 - pop a and b from top and push b<op>a to top
 ?20 - pop and declare label with popped element as its name
 =20[...] - pop a and b from top and if they are equal execute code inside the brackets
 >20[...] - pop a and b from top and if they b>a equal execute code inside the brackets
 <20[...] - pop a and b from top and if they b>a equal execute code inside the brackets
 "20 - pop element and goto label which names is equal to popped value
 :20 - duplicate top element
 ;20 - pop a and b then push b a times
 number from 0 to 9 followed by 21 - enqueue x
 +, -, * or / followed by 21 - pop a and b from bottom and push a<op>b to the bottom
 ?21 - dequeue and declare label with dequeued element as its name
 =21[...] - pop a and b from bottom and if they are equal execute code inside the brackets
 >21[...] - pop a and b from bottom and if they a>b equal execute code inside the brackets
 <21[...] - pop a and b from bottom and if they a>b equal execute code inside the brackets
 "21 - dequeue element and goto label which names is equal to dequeued value
 :21 - duplicate bottom element
 ;21 - dequeue a and b then enqueue a b times
 & - pop element from bottom and push it to top
 $ - pop element from top and push it to bottom
Category:Languages Category:Turing complete
SQRT

SQRT is a programming language with the theme of algebra by User:ZirconiumX. 
== Basic features of SQRT ==
All SQRT statements are in the format
 <variable>=<variable><operand><variable>
or maybe
 <variable>=<number><operand><number>
where <operand> can be / * + - & | ^ %
(divide, times, plus, minus, AND, OR, XOR, and modulus respectively)
SQRT statements can be grouped as one statement
 o=20+20+15+15+2
You can use any letter or symbol (but not a number) except o(utput) and i(nput) and v (you'll see why in a bit). So the above example would print 
 H
to standard output.
You can also group statements even further by using
 v/
and
 _
where v/ indicates the start of a statement and _ indicates the next statement. (No, there isn't an end marker, simply continue until a newline is reached)
== Advanced features of SQRT ==
 @
means a comment.
 $<number>
is a loop that repeats <number> of times. (equivalent to a (int i = 0; i < <number>; i++) loop)
 !<numberstart><numberend><variable>
is a loop that repeats <numberend>-<numberstart> times, and allows you to use <variable>(equivalent to a (int i = <numberstart>; i < <numberend>; i++) loop)
 ~
breaks out of the loop.
== Hello World examples in SQRT ==
=== Basic ===
 o=72+0
 o=101+0
 o=108+0
 o=108+0
 o=111+0
 o=32+0
 o=87+0
 o=111+0
 o=114+0
 o=108+0
 o=100+0
 o=33+0
 o=10+0
would print
 Hello World!
=== Intermediate ===
 o=v/72+0_101+0_108+0_108+0_111+0_32+0_87+0_111+0_114+0_108+0_100+0_33+0_10+0
would also print
 Hello World!
=== Advanced ===
 $i
 o=v/72+0_101+0_108+0_108+0_111+0_32+0_87+0_111+0_114+0_108+0_100+0_33+0_10+0
would print
 Hello World!
depending on the number you wrote to the program
Category:LanguagesCategory:2011
SRlang

SRlang, sometimes called Computational Amazigh or RiffiLang, is a Python-interpreted programming language created by User:Soyuzguy123!. The language is made to be translated into multiple languages in North Africa so that people who natively speak the language can write code in said language. Currently, the main plans are to translate the current English syntax to Amazigh, Darija, and Kabyle. The language is limited and as of now can only use three variables: x, y, and z.
The looping method of the language uses the ability to load another SRlang program multiple times.
Documentation is being made to ensure the language can be learned easily.
==Code examples==
===Hello, World program===
English Syntax
 "com.say:Hello, World!"
Riffi Amazigh Syntax
 "com.swr:Azul, Ard!"
===Truth-machine===
English Syntax:
(filename matters so for now lets call it Truthmachine.txt)
 "x = usr.say:enter a number:"
 "if x :: '0;com.say:you entered 0"
 "if x :: '1;com.say:you entered 1"
 "if x :: '1;loop:Truthmachine.txt"
 "stop;"
Riffi Syntax:
 "x = ewd.swr:ari ijn numero:"
 "mř x :: '0;com.swr:šəkk ari 0"
 "mř x :: '1;com.swr:šəkk ari 1"
 "mř x :: '1;ʕawd:Truthmachine.txt"
 "kumr;"
==External resources==
Interpreter will be released once the Riffi version is finished as well.
* SRlang-V1.2(English edition)
Category:Languages
Category:2019
Category:Implemented
Category:Turing complete
Category:Languages
Category:Thematic
SS

SS is short for "Stack Symbols". It is a stack-based program language, you can use all normal printable ASCII symbols as well as the special ones: You also have to write the symbols in different colors for different meanings.
Please anyone, improve it, make suggestion etc. If you can suggest what meaning should some of the symbols be, you can do that if you want to. Or suggest what colors are used for what purpose.
Category:ideas Category:Stack-based
SSBPL

SSBPL(Simple Stack Based Programming Lamguage) is untyped and stack based programming language by user User:EzoLang.
CMD 	STACK 	EXPLANATION
[x] 	(--l) 	Push pointer to lambda l with code x
+ 	(n1 n2--n) 	Push n1+n2
- 	(n1 n2--n) 	Push n1-n2
* 	(n1 n2--n) 	Push n1*n2
/ 	(n1 n2--n) 	Push n1/n2
% 	(n1 n2--n) 	Push n1 mod n2
! 	(l--) 	Execute lambda at address l
? 	(n l--) 	If n is nonzero then execute lambda at address l
# 	(l1 l2--) 	Repeat l2 while top of stack after l1 is nonzero
& 	(n1 n2--n) 	Push n1&n2
 	(n1 n2--n) 	n2
^ 	(n1 n2--n) 	Push n1 xor n2
_ 	(n--n) 	Push !n1
123 	(--n) 	Push number
'c 	(--n) 	Push ascii of c
@ 	(p--x1..xn) 	Push data from address of pointer p and free memory at address of p
\ 	(x1..xn n--p) 	Pop n levels of stack to address of pointer p and push pointer p
. 	(n--) 	Output n as char
, 	(--n) 	Push ascii of inputted char
; 	(n--n) (--n) 	Store top of stack and after exiting push strored value
= 	(x1 x2--n) 	Push x1==x2
< 	(x1 x2--n) 	Push x1<x2
> 	(x1 x2--n) 	Push x1>x2
: 	(n--) 	Pop
$ 	(n--n n) 	Push copy of n
~ 	(n1 n2--n2 n1)	Swap positions of two topmost stack items
(x) 	(--) 	Comment
a..z	(--p) 	Push pointer to variable a..z
` 	(n p--) 	Store and pop 1 level of stack to address of pointer p
" 	(p--n) 	Load 1 word of data from address of pointer p
When function exits it returns to address at the top of stack so stack is like return stack in forth. If there is something in stack when lambda is executed then top of stack before lambda execution is popped and pushed to stack after return addresses. Whitespace is used to separate two numbers from each other.
&, |, ^ and _ are bitwise operators. =,< and > return true or false with 0 as false and 65535 as true. Everything in stack is 16bit. Variables a..z are global.0
== Examples ==
Fibonacci sequence
 0a`1b`1 (Put 0 to a, 1 to b and 1 to top of stack)
 [10<;:] (Is number on the top of the stack smaller than 10?)
 [a"b"+ (Load a and b and then add them together)
 b"a` (Load b and store it to a)
 $b` (Duplicate and store to b)
 $'0+. (Duplicate, convert to ascii and output)
 ;:] (Save result for smaller than 10 check, pop it and exit lambda)
 # (loop)
Hello, world!
 'H.'e.'l$..'o.',.' .'w.'o.'r.'l.'d.'!.
SSREPL

SSREPL(Simple String-Rewriting Esoteric Programming Language) is an esolang by User:ChuckEsoteric08 inspired by Novice.
==Specification==
Initial value Data String is taken from user input. Line numbers are 1-indexed. There is only one instruction:
 x=y!z
If there is x in Data String replace it with y, else goto line z.
==Computational class==
SSREPL is Turing complete, which is proven by this Cyclic Tag interpreter:
^@=@!6
@#=@!4
*=*!19
$=$^!19
*=*!1
^;=;^!11
@0=@!9
*=*!1
@1=@!19
*=*!1
^1=1^!15
@1=@1!1
#=1#!19
*=*!1
^0=0^!19
@1=@1!1
#=0#!19
*=*!1
@=@!19
Initial Data String should look like this: $^Program@Data#.
==See also==
* SSREPL```
Category:Languages Category:Turing complete Category:Turing tarpits Category:No IO Category:String-rewriting paradigm Category:Unimplemented
SS (CatLooks)

SS is an esoteric programming language created by CatLooks.
==Overview==
Each line in SS is written in int [byte] style.
It uses console I/O, has 2 registers and 256 bytes of shelf memory.
==Memory==
There're 2 registers: data & buffer. Each of them contain a single byte representing an unsigned integer.
For more space we have 256 bytes of shelf memory.
Shelf memory is a type of memory similar to stack memory.
When you push a byte, everything moves to the left and the last byte is overwritten with value in data.
When you pop a byte, everything moves to the right and the last byte is moved to data.
You can also rotate the whole thing, either right or left.
==Instructions==
Opcode 	Description
set <byte>	Sets a value for data
add <byte>	Adds a value to data
sub <byte>	Subtracts a value from data
and <byte>	ANDs data by value
orb <byte>	ORs data by value
xor <byte>	XORs data by value
mov 	Moves data to shelf
pop 	Pops the top byte to data
rol 	Rotates shelf left
ror 	Rotates shelf right
inc 	Adds 1 to data
dec 	Subtracts 1 from data
rec 	Records data
res 	Restores data
lab <str> 	Creates a label
jmp <str> 	Jumps to label
equ <str> 	Jumps to label if data == buffer
neq <str> 	Jumps to label if data != buffer
gtr <str> 	Jumps to label if data > buffer
lss <str> 	Jumps to label if data < buffer
geq <str> 	Jumps to label if data >= buffer
leq <str> 	Jumps to label if data <= buffer
jsr <str> 	Jumps to label as a subroutine
rts 	Returns from subroutine
end 	Exits program
out 	Output data as an ASCII character
inp 	Input a single character into data
int <byte>	Outputs data as a number in the system (2, 8, 10, 16)
str <str> 	Outputs a string (\n = new line, \r = blank, \s = space, \t = tab)
==Interpreter==
I wrote Python interpreter which is available on .
SStack

SStack (Seven Stacks) is an esolang by User:ChuckEsoteric08 inspired by Kipple and was designed as more powerful version of Sreg.
==Commands==
SStack uses seven stacks:a, b, c, d, e, f and g, each containing unsigned integers. If you try to accsess empty stack then it would return 0. Decrementing zero is a nop
 >x/y< - pop element from stack x and push it to stack y
 +x/y+ - pop element from stack x, increment it and push it to stack y
 -x/y- - like +x/y+ but decrement
 ;x; - push ASCII value of next byte of user input to stack x
 :x: - output top of the stack x as ASCII character
 "x/y" - push x to stack y
 [x\y/code] - execute code while top of the stack x and top of the stack y are equal
==Computational class==
There is (untested) brainfuck interpreter created in SStack:
"1/a""1/b""33/c""0/d"
[a\b/
 ;d;
 [d\c/
 >c/b<"0/c"
 ]
]
~b~
[a\b/
 >d/e<
 [d\c/
 >c/b<"1/c"
 ]
]
~b~~c~"256/c""0/c"
[a\b/
 "0/g"
 "43/g"
 [g\e/
 +c/c+
 "1/g"
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 "45/g"
 [g\e/
 -c/c-
 "1/g"
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 "62/g"
 [g\e/
 >f/c<
 "1/g"
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 "60/g"
 [g\e/
 >c/f<
 "1/g"
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 "44/g"
 [g\e/
 ;c;
 "1/g"
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 "46/g"
 [g\e/
 :c:
 "1/g"
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 "91/g"
 [g\e/
 "0/g"
 [c\g/
 [a\b/
 "0/g"
 >e/d<
 "91/g"
 [g\d/
 [a\b/
 ~g~
 "0/d"
 [d\g
 "2/b"
 ]
 ~d~
 ]~b~
 ~g~+g/g+
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 "0/g"
 >e/d<
 "93/g"
 [g\d/
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 ~g~"0/d"[d\g/"0/b"~g~]~d~-g/g-
 ]~b~
 ]
 ]
 "1/g"
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~>e/d<
 "93/g"
 [g\e/
 "0/g"
 [c\g/
 [a\b/
 "0/g"
 >d/e<
 "91/g"
 [g\d/
 "0/b"
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 ~g~+g/g+
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 "0/g"
 >e/d<
 "93/g"
 [g\d/
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 ~g~"0/d"[d\g/"0/b"~g~]~d~-g/g-
 ]~b~
 ]
 "1/g"
 ]
 [a\b/
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
 >e/d<
 "256/g"
 [c\g/
 "0/c"
 ]
 ~g~
 "0/d"
 [d\g/
 "2/b"
 ]
 ~d~
 ]~b~
]
New lines were added for readability, but they are optional. Input is seperated from program by ! like in dbfi
Category:Languages Category:Turing complete Category:Unimplemented
STACKIE

Stackie is a two-dimensional esoteric programming language originally devised by the Minecraft player Woffur as a game on the DiamondFire Minecraft server. The language is heavily inspired by Befunge. Code is laid out as a two-dimensional grid of blocks, and execution can proceed in any direction of the grid.
The game is accessible on Minecraft server mcdiamondfire.com upon running the command /join 50633.
==Language overview==
A Stackie program is laid out on a two-dimensional grid. The grid can either be a grid of ASCII characters (as in the reference implementation) or Minecraft blocks (as in the original game). Each cell on the grid represents a single instruction.
Execution proceeds by means of an instruction pointer. This points to a grid cell on the grid. The instruction pointer has inertia: it can travel to any of the four cardinal directions, and keep traveling that way until an instruction changes the direction. The instruction pointer begins at an Input and begins moving in the Input's direction. Stackie has no jumps farther than two cells, so control flow is done by altering the direction of the program counter, sending it to different literal code paths. The following, for example, is an infinite loop:
 >v
 ^<
Stackie programs store data on a stack.
==Instructions==
Stackie has the following commands:
Command	Name 	Description 	Block
^ 	Redirector	Redirects the pointer to face north.	Magenta Glazed Terracotta
v 	Redirector	Redirects the pointer to face south.	Magenta Glazed Terracotta
< 	Redirector	Redirects the pointer to face west. 	Magenta Glazed Terracotta
> 	Redirector	Redirects the pointer to face east. 	Magenta Glazed Terracotta
X 	End 	Halts the program.
The output buffer is not submitted.	Coal Block
# 	Jump 	Skips the next block. 	Slime Block
==Examples==
===Hello World===
 >+:.*P0.....:+v
 :v,P...:P:P,,<:
 .,>,,,P0....v,*
 .,, :,.
 .:, :,:
 .P, +,P
 0,, *,.
 ]^>^ >.,.@X
 >v P,.
 .. ^<+.
 .* +.
 ., :.
 :P :.
 .>0....::+*:P^:
 ^....0P:...P:P<
Category:Languages
Category:Stack-based
Category:Linear bounded automata
Category:Two-dimensional languages
Category:Implemented
Category:Low-level
Category:2021
STOD

STOD (STringmODifier) is an esoteric programming language, like brainfuck, but based on string modifying.
== Examples ==
=== Hello, world! ===
"Hello, world!"#
=== Counts from 5 to 0 ===
"5"[#@-]
=== Counts from user input to 0 ===
?[#@-]
=== Quine ===
">++++++++++++++++++++++++++++++++++.<#>.<#">++++++++++++++++++++++++++++++++++.<#>.<#
== Docs ==
All default brainfuck instructions are included, as well as some new ones:
Instruction	Desc
? 	Ask user for input, and put value into current cell.
# 	Output current cell value
@ 	Prints line feed
! 	Set current cell value to 0
h 	Stop program execution
"anydata" 	Puts data betwen " into current cell
(anydata) 	Comment
== External resources ==
* Javascript interpreter (PHP file type) (dead link)
Category:Languages
Category:2016
Category:Implemented
Category:Turing complete
Category:Brainfuck derivatives
Category:Turing tarpits
Category:Low-level
Category:Cell-based
STRTRAN

STRTRAN '(string transformer)' is an esolang thought up by User: Froginstarch it is a String Rewriting language like thue, but made by an idiot
In this programming language, you manipulate a string with comparisons, concatenation, and replacements
== Comparisons ==
The comparison of 2 strings is done by the compare -> statment
This takes 2 strings and compares them. If equal then run True, if not equal then run False
comp stringA -> stringB 
 true /- something -/ etrue
 efalse /- something else idk -/ efalse
ecomp
== Concatenation ==
Concatenation is done with the ++ operator, this takes 2 strings and concatenation them into one string
"Hello " ++ "World!" /- "Hello world" -/
== Replacing ==
You can replace specific characters in a string using the replace in with statement
replace "h" in "hi" with "b" /- hi -> bi -/
== Templates ==
templates are this programming languages equivalent of functions, its also how you can do looping through the most optimal looping method, recursion. (note to reader: this was a mistake)
temp goobIt {a, b} do
 a ++ b ++ "goob"
etemp
== IO ==
: idk why this is a separate section but idk so suck it up nerd :)
IO in this language is made to be mighty simple.
they are done with the readstdin and outstdout instruction 
an example of IO is the coveted TRUTH MACHINE 
temp loop{} do
 comp readstdin -> "1"
 true 
 outstdout "1" 
 loop{}
 etrue false 
 outstdout "0"
 efalse
 ecomp
etemp
loop{}
== More Examples ==
Hey unsuspecting Esolanger! If you want to add some examples that you might have thought up. Thanks in advance :)
== Computing class ==
as the writer as of now hasn't written an interpreter, so he isn't entirely sure. so yeah :p
Category:Languages Category:Unimplemented
STRong

STRong is a language made by User:Qawtykit to add more features to a string-rewriting paradigm. 
 
== Program Structure == 
Programs in STRong start with the initial string, followed by a newline. Then you write the program, which is read from top to bottom. 
If a find/replace finds multiple strings, all of them are replaced.
== Commands and Expressions == 
Each command is ended with a newline 
Command 	Description 	Example usage
'string'replacement 	Find and replace on the initial string 	'asdf'fasd
:string:n 	set variable n to string 	:asdf:fasd
!string!replacement!v	find and replace on variable v 	!asdf!tyrant!fasd
.n 	define jump point named n 	.asdf
^string^n 	jump to jump point n if string is found in the initial string	^fasd^asdf
*...* 	comment 	*this will be ignored*
 
Jumping to label "end" terminates the program.
These are expressions placed within a string, they also work in the initial string: 
Expression 	Description 	Example usage
? 	return line from input 	'p'? *replace p with input*
# 	return entire initial string 	'#' *clear initial string*
☼ 	any character, does not work in initial string 	'!☼☼☼☼d'!☼☼☼☼f *replacement from distance away*
str∞str 	any amount of space can be between two strings 	'[∞]'asdf *check for balanced brackets*
(n) 	return unicode character corresponding to n 	(10)*newline*
~ 	concatenate two string expressions 	(10)~#
n[string&string]	n% chance to return string on left, else return string on right 	50[heads&tails] *coin flip*
{string} 	string in curly brackets will not be removed when replaced, instead replacement will be placed to the right of it	'{a}'b *infinite loop*
<string> 	string will be output to the console 	'@'<Hello, World!>
== Examples ==
=== Truth-machine ===
i
'i'? *Ask for input*
^0^zero *If the input is 0:*
^1^one *Whereas if the input is 1:*
^#^end
.one
'{i}'<1> *Output 1*
^1^one *Repeat infinitely*
.zero
'i'<0> *Output 0.*
.end *Terminate program*
=== Unary subtraction ===
a-b
'a'? *input sequence of 0s for unary number*
'b'?
'-∞0'1 *convert every 0 on right into 1*
.loop
'01'
^01^loop
'1'0
0'<0>
Category:LanguagesCategory:String-rewriting paradigmCategory:UnimplementedCategory:Turing complete
SUBBIG

SUBBIG (SUBtract and jump if BIGger than zero) is an OISC by User:ChuckEsoteric08.
==Description==
SUBBIG has memory-mapped commands, with them being at the start of a memory and everything else being 0.
 a b c
Subtract memory address b from memory address a and jump to memory address c if result was bigger than zero. If you try to goto to address -1 program halts
===I/O===
 a -1 c
Would set memory address a to user input.
 -1 b c
Would output memory address b.
I/O Could be either character-based or integer-based depending on implementation.
==Programming in SUBBIG==
For simplicity we will use assembly-like syntax. Where
 X:Y
Means "Declare label X with value Y". And :X would return location of label X.
 a b NEXT
Means "Go to the next memory address".
 a b HALT
Means "Execute command and halt".
===Writing a program that prints "Hi"===
Note that this program would only work in a version with character-based I/O:
 -1 :H NEXT
 -1 :I NEXT
 -1 :! HALT
 H:72 i:105 !:33
First three lines are dedicated for outputing value of value of labels "H", "i" and "!" with last line ending in "HALT" so the program would halt without executing last line. Last line of code contains value of this labels.
In normal SUBBIG it would look like this:
 -1 10 3
 -1 11 6
 -1 12 -1
 72 105 33
===Writing Truth-machine===
This one is a little bit harder.
====Version for character-based I/O====
 :X -1 NEXT
 :X :SUB :preloop
 -1 :X NEXT
 :X :NEG HALT
 preloop::X ADD :loop
 loop:-1 :X :loop
 X:0 SUB:48 NEG:-1
 ADD:-48 0 0
First you need to type either 0 or 1 and store it in X. Then subtract 48 and if result was bigger than 0 goto label preloop where 48 is added to X and goto label loop where it prints X infinitly. Else We would print 0 and halt.
Here it is in normal SUBBIG:
 19 -1 3
 19 20 13
 -1 20 9
 19 21 -1
 19 22 16
 -1 19 16
 0 48 -1
 -48 0 0
====Version with integer-based I/O====
This version is a lot easier to do than in character-based I/O version:
 :X -1 :loop
 -1 :X HALT
 loop:-1 :X :loop
 X:0 0 0
In normal SUBBIG:
 9 -1 6
 -1 9 -1
 -1 9 6
 0 0 0
Category:Languages Category:Turing complete Category:OISC Category:Self-modifying Category:Unimplemented
SUTRAGNEZOl

SUTRAGNEZOl stands for SUbtract and TRy AGain with new NUmber if Equal too Zero Or Less.SUTRAGNEZOl is a OISC. in SUTRAGNEZOl you can do one thing. it is where you have a memory adress A. then you subtract whats in memory adress B from A. if this is more than 0 we store the result in B. else if the result less than or equal too 0 we try again but with c instead of B. then if this is also lessthan or equal to 0 the memory pointer goes to D. you write this like shown below: 
 #A, B, C, D
example:
 #1, 2, 3, 4
Category:OISC
Category:Output only
Category:Unimplemented
Category:Low-level