nyuuzyou/wikis huggingface dataset:
Her

:Note that the Russian for Her is Её. Ее is not a valid name for the language.
Her, or YeYo, is an esoteric programming language for steganography created by User:Orisphera.
== Input format ==
The program is a text written in Russian. The characters in the program that are important to the language (hereafter basic characters) are the letter Е (Ye) where Ё (Yo) would look innocent (hereafter 0) and Ё where Е would look innocent (hereafter 1). Other characters are only used to determine whether the other letter would look innocent and therefore whether to count it. The case of the letter, depending on the implementation of this part, is either ignored completely or used for the same, but either way, both uppercase and lowercase Е and Ё should count as long as the other letter of the same case would look innocent.
== Commands ==
=== IMP ===
There are different types of commands in Her, and they all have different Instruction Modification Parameters (IMP).
You have to do IMP first, then command. The parameters end with a linefeed.
IMP	Command
00 	Literals
011	I/O
100	Stack Manipulation
11 	Arithmetic
010	Flow control
101	Heap access
=== Literals ===
In Her, you can only input numbers from 1 to 255 directly. To do so, first, write 00 to switch to literal mode. In literal mode, each command is 8 basic characters. It pushes the corresponding value (little-endian) to the stack. 00000000 exits the literal mode.
=== I/O ===
Command	Meaning
10 	Read a character and put it on the stack
11 	Read a number and put it on the stack (numbers inputted this way don't have to be in the range that literals have)
00 	Pop a character and output it
01 	Pop a number and output it
Basically, all you need to remember is first, 1 for input, 0 for output, and second, 0 for a character, 1 for a number.
=== Stack Manipulation ===
Commands	Meaning
10 	Duplicate the top item on the stack
11 	Swap the top two items on the stack
00 	Discard the top item on the stack
010 	Pop n. Then, copy the nth item on the stack onto the top of the stack
011 	Pop n. Then, slide n items off the stack, keeping the top item
=== Arithmetic ===
Command	Meaning
00 	Addition
01 	Subtraction
10 	Multiplication
110 	Integer Division
111 	Modulo
=== Flow control ===
Commands 	Meaning
00<label> 	Mark a location in the program
011<label>	Call a subroutine
010<label>	Jump unconditionally to a label
100<label>	Jump to a label if the top of the stack is zero
101<label>	Jump to a label if the top of the stack is negative
110 	End a subroutine and transfer control back to the caller
111 	Ends the program
===Heap Access===
Heap access commands look at the stack to find the address of the items to be stored or retrieved. To store an item, push the address, then the value, and run the store command. To retrieve an item, push the address and run the retrieve command, which will place the value stored in the location at the top of the stack.
Command	Meaning
0 	Store
1 	Retrieve
Hev

Hev is an esoteric programming language designed by Chris Pressey between 2005 and 2007. It purports to solve the "central problem of infix notation": avoid making the programmer ever supply parentheses, and avoid requiring the programmer to ever memorize precedence tables.
==External resources==
* 
Category:Languages
Category:Implemented
Category:No IO
Category:Turing complete
Category:2007
Hex0

== hex0 ==
Hex0 is trivial to implement 
It just needs to read 2 hex nybbles and output a byte, you can ignore all non-hex characters but you need to support 2 types of line comments{# and ;}
; This is a line comment
# So it is
;; And this
## And this
;; but to be polite please don't mix in non-hex characters in the hex stream,
## it doesn't make you clever, it just makes your code harder to read
# Done
48 c7 c7 00 00 00 00 # mov $0x0,%rdi
48 c7 c0 3c 00 00 00 # mov $0x3c,%rax
0f 05 # syscall
Example of .hex0 code from hex0
This maps out an ELF file for Linux which implements a compiler for hex0 (!).
A reduced subset of hex0 is called boot0 and lacks support for line comments and restricts input to only numbers, upper case A-F, space and the enter key; as it expects humans to be entering input and know not to also type the comments. (All boot0 files are valid hex0 and all hex0 files being manually typed in can be converted to boot0 at enter time by the humans performing that input)
==See also==
* hex1
* hex2
Category:Bootstrapping Category:Languages
Hex1

Hex1 is the most obvious and logical extension of the hex0 language. As the hardest part of writing programs in hex is having to manually count bytes to know the size of the offset needed for jumps and loops. So we add single letter labels (such as :a and :b) and a single sized offset pointer which will automatically populate with the offset (@a and @b)
below is the list of common prefix symbols for the offset pointers:
* ! - 8 bit relative address
* @ - 16 bit relative address
* % - 32 bit relative address
* ~ - architecture specific relative (usually 24bit)
* $ - 16 bit absolute address
* & - 32 bit absolute address
; First pass loop to determine addresses of labels
:f ;First_pass
 13 01 81 FF # RD_SP RS1_SP !-8 ADDI ; Allocate stack
 23 30 11 00 # RS1_SP RS2_RA SD ; protect ra
:1 ;First_pass_loop
 $R EF 00 00 00 # RD_RA $Read_byte JAL ; Get another byte
 ; Deal with EOF
 13 03 C0 FF # RD_T1 !-4 ADDI
 @3 63 00 65 00 # RS1_A0 RS2_T1 @First_pass_done BEQ
Example of .hex1 code from hex2
==See also==
* hex0
* hex2
Category:Bootstrapping Category:Languages
Hex2

Hex2 is the most complex hex based language you probably would ever want to make and is the final logical conclusion of the hex0/hex1 series of languages. Extending to support multiple pointer sizes and formats as well as alignment and word oriented features and removing the single character label restriction of hex1 and enabled long label names
The prefixes for the pointers are standardized as:
* ! - 8 bit relative address
* @ - 16 bit relative address
* % - 32 bit relative address
* ~ - architecture specific relative (usually 24bits)
* $ - 16 bit absolute address
* & - 32 bit absolute address
Some exotic architectures with alignment and other messy details include:
* < pad to alignment
* . insert to word
* ^ word aligned calculation
# ;; Set p->Next = p->Next->Next->Next
18020000	# LOAD32 R0 R2 0 ; Get Next->Next->Next
23010000	# STORE32 R0 R1 0 ; Set Next = Next->Next->Next
:Identify_Macros_1
18010000	# LOAD32 R0 R1 0 ; Get node->next
A0300000	# CMPSKIPI.NE R0 0 ; If node->next is NULL
3C00 @Identify_Macros_Done	# JUMP @Identify_Macros_Done ; Be done
# ;; Otherwise keep looping
3C00 @Identify_Macros_0	# JUMP @Identify_Macros_0
:Identify_Macros_Done
# ;; Restore registers
0902803F	# POPR R3 R15
0902802F	# POPR R2 R15
0902801F	# POPR R1 R15
0902800F	# POPR R0 R15
0D01001F	# RET R15
:Identify_Macros_string
444546494E450000	# "DEFINE"
Example of .hex2 code from M0
==See also==
* hex0
* hex1
Category:Bootstrapping Category:Languages
Hexadecimal Stacking Pseudo-Assembly Language

The Hexadecimal Stacking Pseudo-Assembly Language (HSPAL) is a programming language by User:SuperJedi224 in which a program is represented by a list of six-digit hexidecimal numbers seperated by line breaks (or not at all, the line breaks are optional and, in fact, all other whitespace is forbidden).
Data is stored as 16-bit unsigned integers in up to 256 unbounded-capacity stacks and a single register.
Control structure takes the form of simple conditionals (of exactly one command) and goto statements.
The specifications include a proof of Turing completeness.
==Instructions==
Instruction format is as:
ABXXYY
A is the instruction group
B is the instruction
All operations throw an exception and exit with status code FFFF / -1 if:
* A stack is empty when popped
* Two labels have the same ID
* A label that doesn't exist gets jumped to
If the program finishes with no exit command and no exceptions, the program will exit with an exit code of 0000 / 0.
Opcode: AB
 Instruction group 0: Program Control
Opcode	Details
00 	Make a label with ID XXYY
01 	Goto label XXYY
02 	Pop element from stack XX. Goto label specified by element popped.
03 	Pop element from stack XX. If the element is nonzero, skip the next instruction.
04 	Exit with the exit code of XXYY.
 Instruction group 1: Input / Output
Opcode	Details
10 	Get user input as Unicode character, EOF = 0 and push onto stack XX
11 	Get user input as number, EOF = 0 and push onto stack XX
12 	Pop number off stack XX and output as number
13 	Pop number off stack XX and output as character
14 	Pop values off stack XX until empty, outputting each element as Unicode characters in the order popped. Do nothing if stack is empty.
==Examples==
===The Hello, World! program:===
200021
400000
200064
400000
20006C
400000
200072
400000
20006F
400000
200057
400000
200020
400000
20002C
400000
20006F
400000
20006C
400000
20006C
400000
200065
400000
200048
400000
140000
===A (horribly slow) 16-bit Brainf*** interpreter===
Translated from Daniel B Cristofani's Brainf*** self-interpreter.
It can be found here. Input is program source followed by program input, seperated by an !.
Technically non-standard, as it uses unsigned shorts while Brainf*** proper uses unsigned bytes.
==Interpreters==
The source for a java-based interpreter can be found here.
Additionally, there exists a Ruby interpreter which relaxes the syntactic restrictions mandated by the specification, but otherwise aims to hew very closely to the behavior defined therein. 
Category:LanguagesCategory:2015Category:Stack-basedCategory:Turing completeCategory:Implemented
A JavaScript online interpreter can be found here.
A Python interpreter can be found here.
Hexagon says jump to line a if cell b is n and increment cell b by c if cell b equals d and output cell b is cell b equals e.

Hexagon says jump to line a if cell b is n and increment cell b by c if cell b equals d and output cell b is cell b equals e. is an esolang created by Infinitehexagon which is his first OISC. Unfortunately, there is a spelling error at "output cell b is cell b equals e" where "is" is supposed to be an "if".
==Keywords==
all is any value.
random is a random value.
null is an empty character.
==Instruction==
Instruction
Hexagon says jump to line a if cell b is n and increment cell b by c if cell b equals d and output cell b is cell b equals e.
==Programs==
=== Truth machine ===
 Hexagon says jump to line 3 if cell 0 is 1 and increment cell 0 by 0 if cell 0 equals 1 and output cell 0 is cell 0 equals 1.
 Hexagon says jump to line 4 if cell 0 is 0 and increment cell 0 by 0 if cell 0 equals 0 and output cell 0 is cell 0 equals 0.
 Hexagon says jump to line 1 if cell 0 is 1 and increment cell 0 by 0 if cell 0 equals 1 and output cell 0 is cell 0 equals 1.
 Hexagon says jump to line 5 if cell 0 is 0 and increment cell 0 by 0 if cell 0 equals 0 and output cell 0 is cell 0 equals 0.
Category: LanguagesCategory:2024Category:OISCCategory:Cell-basedCategory:Unknown computational classCategory:Output onlyCategory:Low-level
Hexagrid

Hexagrid was designed by Emil Svensson (:User:fr34k) in 2008. The name comes from how one codes in Hexagrid (hexadecimal grid).
==Overview==
Initially, when you code in Hexagrid, one has a virtual grid of the hexadecimal codes with pointers starting in the uppermost left corner.
 v
 >0 1 2 3
 4 5 6 7
 8 9 A B
 C D E F
This is only for clarification, and is never shown when coding. One has to keep track of the pointer in his/her head.
By moving the pointer around one can add hexadecimal codes to different stacks.
==Commands==
Command 	Function
> 	Move pointer to the right
< 	Move pointer to the left
^ 	Move pointer up
v 	Move pointer down
Add to stack	
! 	Clear stack and reset pointer
o 	Output stack
x{ } 	Define a stack where the stack is x
==Examples==
===Basics===
Moving the pointer, defining a stack and adding data to it
Before we can code anything we need to define a stack that we want to work with. Remember that you can work with as many stacks as you like, the only rule is to work with the coding inside the stack limitations ({ and }). Let's call our stack myStack.
 myStack{};
First of all we clear the stack and reset the pointer
 myStack{!};
After that we can move the pointer using <, >, ^ and v. Let's say we want to move our pointer to A in the grid.
We move the pointer two steps to the right, then two steps down.
 myStack{!>>vv};
Let us then add this data to the stack using the + command
 myStack{!>>vv+}
If you want to move the pointer anywhere else, keep in mind that the pointer now points at A.
Now let's output the stack. We then use the o command
 myStack{!>>vv+o};
Wich would output
 A
==Hello, world!==
This is a Hello, World! program in Hexagrid
 stack{!v+v+^>>+<+>+<<vv+^^>>+<<vv+^^>>+vv>+<^^^+<<+>v+>>+<+>vv+^^+^<+v+<<vv+^^>>+<<+^>>+<+o};
which will output
 Hello World!
or in hexadecimal code
 48656C6C6F20576F726C6421
==Implementations==
hexagrid.rb - Hexagrid interpreter in Ruby
Category:2008
Category:Languages
Category:Implemented
Hexdump

Hexdump is an esolang invented by User:None1.
==Execution==
All programs in hexdump are hex dumps, when running, hexdump simply converts its program into normal text.
==Example Programs==
===Hello World===
 48 65 6C 6C 6F 20 57 6F 72 6C 64 21
===Nope. Interpreter===
 4E 6F 70 65 2E
==Interpreters==
===Python===
 print("".join([chr(int(i,16)) for i in __import__("sys").stdin.read().split()]))
==Special Usages==
Some esolangs stores its program as a binary file, so their programs are usually represented as hex dump in websites. You can simply treat these hex dumps as a program in Hexdump and run it to get the actual program that runs correctly.
Category:Languages
Category:Output only
Category:Unusable for programming
Category:Total
Category:Joke languages
Category:2023
Category:Implemented
Hexish

This should be enough for now:
Command	Description
00 	end of data
01 	print
02 	assign
03 	add
04 	multiply
05 	divide
06 	subtract
07 	clear
08 	end
09 	begin
0A 	loop
0B 	hello world
0C 	decrement
0D 	increment
0E 	string indicator
0F 	number indicator
10 	middle
11 	end loop
12 	if
13 	else if
14 	else
15 	ascii art smily face
16-1F 	address
20 	goto
21 	label
22 	get input
This was invented by User:Twistle
==Examples==
===Hello World!===
 0B
===Cat program===
Due to lack of documentation, this assumes that 0A and 11 function like a brainfuck-style loop.
 22 0A 01 22 11
===Truth-machine===
Same assumptions as #Cat program, for the same reasons.
 22 01 0A 01 11
Category:Languages
Category:Unimplemented
Category:2006
Hexlr7

Hexlr7 is a terrible HQ9+ copy made by User:Cortex on 12/18/2018, designed to be easy (but not too easy) to implement. Implementing it might be a good thing to do when bored and with a lot of free time.
== Interpreter, also by Cortex ==
var Hexlr7 = function(code) {
 // H: Print "Hello, World!"
 // E: Print the link to the Esolangs wiki article on this programming language
 // X: Print the source code for a minified interpreter that does not support the X command.
 // L: Print the name of the language the interpreter was written in.
 // R: Make the interpreter throw an error.
 // 7: Do the following command 7 times. Only works with up to 2 sevens; 77HH would print "Hello, World!" 50 times.
 for (var i = 0; i < code.length+1; i++) {
 switch (code.charAt(i)) {
 case "H":
 if (code.charAt(i-1) !== "7") {
 println("Hello, World!");
 }
 break;
 case "E":
 if (code.charAt(i-1) !== "7") {
 println("https://esolangs.org/wiki/Hexlr7");
 }
 break;
 case "X":
 if (code.charAt(i-1) !== "7") {
 println("var Hexlr7=function(code){for(var i=0;i
Category:Languages Category:2018 Category:Unusable for programming Category:Total Category:Implemented Category:Output only
Hexomnia

Hexomnia is a language made by Cortex, inspired by Insomnia. But, instead of reading each character as its (for lack of a better term) ASCII number in Decimal, like Insomnia, Hexomnia reads each character as its two-digit hexadecimal character number instead, making room for more instructions. Apart from the syntax, it is very different from Insomnia.
== Commands ==
Hex digit	What it does
0 	Take a number from user input, and push it onto the stack.
1 	Interpret the next hex digit as a number, and push it onto the stack.
2 	Nop.
3 	Print the top stack value as an ASCII character, and pop it off of the stack.
4 	Pop the top stack value.
5 	Double the top stack value.
6 	Increment the top stack value by 1.
7 	Decrement the top stack value by 1.
8 	Ignore the next [value of the top stack value] hex digits. This is to make comments possible, but very inconvenient.
9 	][@}
A 	
B 	
C 	
D 	
E 	
F 	
== Cat program ==
 0
Hexsp

Hexsp is a programming language made by Otakuto. It is basically Lisp written in Hexspeak. Every code is written in hexadecimal numbers and it is supposed to resemble machine language.
==Translations==
Nil
 hexsp> EE 33
 lisp> ()
Space
 hexsp> EE 00 33
 lisp> ( )
Spaces
 hexsp> 00 EE 00 00 33 00
 lisp> ( )
Number
 hexsp> 55 01
 lisp> 1
 
 hexsp> 55 01 01
 lisp> 257
Negative number
 hexsp> 22 01
 lisp> -1
 hexsp> 22 01 01
 lisp> -257
Quote
 hexsp> 99 EE 55 01 55 02 33
 lisp> '(1 2)
 hexsp> EE 92 07 E0 EE 55 01 33 33
 lisp> (quote (1))
Symbol
 hexsp> DE AD BE EF
 lisp> DEADBEEF
 hexsp> 01 01
 lisp> 0101
 hexsp> 0A 0A
 lisp> 0A0A
True
 hexsp> 77
 lisp> t
Dotted Pair
 hexsp> EE 55 01 11 55 02 33
 lisp> (1 . 2)
 hexsp> EE 55 01 11 EE 55 02 11 EE 33 33 33
 lisp> (1 . (2 . ()))
Escape
 hexsp> 55 FF 55
 lisp> 85
 
 hexsp> 55 FF FF
 lisp> 255
 hexsp> 55 FF 00
 lisp> 0
 hexsp> 22 FF 00
 lisp> 0
 hexsp> AA FF 11 FF 22 FF 33 FF 55 FF 99 FF EE FF FF FF 00 BB
 lisp> AA1122335599EEFF00BB
=Dictionary=
car = CA 70
 hexsp> EE CA 70 EE 55 01 33 33
 01
cdr = CD 70
cons = C0 25
atom = A7 03
quote = 92 07 E0
write = 37 17 E0
 hexsp> EE 37 17 E0 55 01 33
 55 01
begin = BE 91 20
 hexsp> EE BE 91 20 EE 00 EE 37 17 E0 EE 33 33 00 00 EE 37 17 E0 EE 33 33 00 33 33
 EE 33
 EE 33
eq = E9
add = AD D0
 hexsp> EE AD D0 55 01 55 02 33
 55 03
sub = 52 B0
setq = 5E 79
if = 1F
 hexsp> EE 1F 00 77 00 55 01 55 02 33
 55 01
 hexsp> EE 1F 00 EE 33 00 55 01 55 02 33
 55 02
defunc = DE F2 2C
 hexsp> EE DE F2 2C 00 0F 00 EE 01 00 02 33 EE AD D0 00 01 00 02 33 33 EE 37 17 E0 EE 0F 00 55 01 55 02 33 33
 55 03
==Sample Code==
This code will add from 1 to 100.
 EE DE F2 2C 00 10 7A 00 EE 01 00 02 33 EE 1F EE
 E9 00 01 00 02 33 EE C0 25 00 02 EE 33 33 EE C0
 25 00 01 EE 10 7A EE AD D0 00 01 00 55 01 33 02
 33 33 33 33 EE DE F2 2C 00 F0 1D 00 EE 0F 00 A0
 00 A5 33 EE 1F EE E9 00 A5 00 EE 33 33 A0 EE F0
 1D 00 0F 00 EE 0F 00 A0 EE CA 70 00 A5 33 33 EE
 CD 70 00 A5 33 33 33 33 00 EE 37 17 E0 00 EE F0
 1D 00 AD D0 00 55 FF 00 EE 10 7A 00 55 01 55 64
 33 33 33
,which translates to this Lisp program:
 (defunc iota (a b)(if(eq a b)(cons b ())(cons a(iota(add a 1)b))))
 (defunc fold (s t u)(if(eq u ())t(fold s (s t(car u))(cdr u))))
 (write (fold add 0 (iota 1 100)))
==External resources==
*The inventor's tweet of completion
*Interpreter on GitHub
Category:Languages
Category:2018
Category:Functional paradigm
Category:Turing complete
Category:Implemented
Hexssembly

Hexssembly is an esolang designed by User:Infinitehexagon to mimic assembly language. 
Instructions	Description
JUMP a b 	Jump to label b when argument a is equal to label b.
NEW b 	Create new label b.
END b 	End label b.
INC b 	Increment the acumulator by b in hexadecimal.
OUT 	Output the accumulator
INP b 	Input a hexadecimal value to the accumulator.
DEC b 	Decrement the acumulator by b in hexadecimal.
SEV a b 	Set variable a to argument b.
DIS b 	Display variable b.
ADD a b 	Add hexadecimal b to variable a.
SUB a b 	Subtract hexadecimal b to variable a.
==Program Examples==
===Hello World Program===
INC 48 |h|
OUT
INC 001D |e|
OUT
INC 0007 |l|
OUT
OUT
INC 0003 |o|
OUT
DEC 002B |\44|
OUT
DEC 000B |\32|
OUT
INC 004C |W|
OUT
INC 0018 |o|
OUT
INC 0003 |r|
OUT
DEC 0006 |l|
OUT
DEC 0008 |d|
OUT
DEC 004F |!|
OUT
Category:LanguagesCategory:2023Category:UnimplementedCategory:Low-level
Hey stack!

Hey stack! is a 4th-generation language where you have to declare everything before you use these things. It is a meta-language that can be used to describe anything physical other than physical data structures. It was said to have so much syntactic sugar that it "rots your teeth". It has notably more syntactic sugar than any other meta-language.
== Background ==
You are in an alternate universe where all data structure components are angry at you because you accidentally set a fire and burnt every computer. So (, unfortunately), you have to greet all of the data structures to use them normally.
== Ways of greeting ==
Hey stack! has tons of syntactic sugars. However, these are simply for greeting these data structures' components (the ellipsis represent the names of the components of data structures):
Hey ...!
Hi ...!
Hello ...!
Howdy ...!
Salutations ...!
Nice to meet you ...!
Greetings ...!
Good morning ...!
Good evening ...!
How are you ...?
What's up ...?
What's good ...?
What's new ...?
What's going on ...?
How are you ...?
How are you doing ...?
How is it going ...?
How are things ...?
How is life ...?
How do you do ...?
How is life treating you ...?
How's everything ...?
What have you been up to ...?
Long time no see ...!
I am glad to meet you ...!
I haven't seen you in ages ...!
Long time no see ...!
How are you going ...?
You should change the punctuation marks to colons if there are sub-components of this component and add a 4-space indentation. You can of course still use exclamation marks or question marks.
== Example: Greeting an array-based stack(simply an array+cursor) with length 5 with a finite length with minimalist defined operations before you use it ==
Hey stack:
 Hey array:
 Hey item1!
 Hey item2!
 Hey item3!
 Hey item4!
 Hey item5!
 Hey cursor:
 Hey integer:
 Hey digit1!
 Hey digit2!
 Hey digit3!
 Hey digit4!
 Hey automation:
 Hey pushStack:
 Hey copyValue!
 Hey triggerCursorIncrement!
 Hey popStack:
 Hey triggerCursorDecrement!
Now the user should be able to use this stack normally.
== Description of Conway's Game of Life Cellular Automaton in Hey stack! ==
Hey ConwayGrid:
 Hey stateDead, Alias " ":
 Hey ConditionToAlive:
 Hey FullfillEither:
 Hey 3Alive!
 Hey 5Dead!
 Hey stateAlive, Alias "*":
 Hey ConditionToDead:
 Hey FullfillEither:
 Hey 4Alive!
 Hey 7Dead!
== Computational power ==
It can be argued that it is a bounded-storage machine, as it can describe Turing-complete systems plus defining finite input.
Category:Languages
Category:Meta-languages
Category:2019
Category:Unimplemented
Hi

Hi is a trivial esolang where everything prints "hi".
== Examples ==
Hello, World!
Output:
hihihihihihihihihihihihihi
==Implementations==
Two implementations in Common Lisp shall be adduced, the first resorting to a short cut by exploiting the Hi source code length, the second veridically processing its content.
The nimble counting variant assumes the form:
 (defun interpret-Hi (code)
 "Interprets the piece of Hi source CODE and returns NIL."
 (declare (type string code))
 (loop repeat (length code) do (format T "hi")))
A rendition invested with enhanced honesty and industriousness constitutes:
 (defun interpret-Hi (code)
 "Interprets the piece of Hi source CODE and returns NIL."
 (declare (type string code))
 (loop for token of-type character across code do (format T "hi")))
Four implementations in Python shall also be adduced:
 print("hi"*len(input()))
the second:
 print("".join(["hi" for i in input()]))
the third:
 while True:
 for i in input("hi\n"):
 print("hi",end=)
and the forth:
 for I in input():print("hi",end="")
The first two are respectively equivalent to the two Common Lisp implementations above.
A ><> implementation:
 >i:01-=?v00.
 v &0 r+1<
 >&1+&:?v&2-&>"ih"oo&:?v;
 ^ ~< ^ &-1<
… and a brainfuck one too:
 +[,>+<]>-<++++++++[>>+++++++++++++<<-]>[>.+.-<-]
Category:Languages Category:Joke languages Category:Unusable for programming Category:Total Category:Implemented Category:Output only