The Insane Esolang

The Insane Esolang is a bad esoteric language created by User:Galaxtone.
It is akin to a 4-years idea of a programming language, treat it as such.
Uses the same tape as from Brainfuck (Unbounded in both directions, 8-bit)
The tape is lazy and every time a value has been accessed for the first time it assigned a random number.
== Random Number Generator ==
To prevent this language from being completely impossible, this uses an RNG which gives you the same values each time.
 function random() {
 seed = (38674947661 * seed + 58487) % 256;
 return seed;
 }
The initial seed is 142.
== Instructions ==
Notes:
* That every instruction polls the RNG regardless of usage. (The RNG is triggered before execution of the instruction)
* Due to the 8bit limitations, all division is integer division and the end result is modded by 256. (The calculated numbers within the operations are not 8bit, only the end result is.)
* All non-instruction characters are ignored, so comments can exist.
* The ə is a modifier that executes the previous character's inverse, it therefore isn't counted as an instruction and therefore doesn't poll RNG, and it acts an NOP if it is the first instruction or if the modified instruction is a ə instruction.
* The input alphabet, output alphabet and instruction list all start at 1.
* Execute the “ instruction using the “ instruction.
* Modular operations should not result in negative numbers. e.g. 6 % 5 = 1, -2 % 5 = 3.
* Always-positive modular implementation if none is available: x - (floor(x / y) * y)
Symbol	Substitute	Operation 	Reverse Operation 	Pseudo-Code 	Reverse Pseudo-Code
À 	A` 	If current random number is greater than 194, Jump forward two instructions. 	If current random number is less than 194, Jump back two instructions. 	{Todo: Add pseudo-code, If you wish to do this yourself, Please look at the Pseudo-Code section of Schmuu's table in Edit mode}	{Todo: Add pseudo-code, You can add a credits section at the bottom listing that you helped if you want :wink:}
θ 	0 	If next cell's value is greater than or equal to 128, Jump forward the current cell's value, divided by 3, plus 1. 	If previous cell's value is less than 128, Jump backwards the current cell's value, multiplied by 3, minus 1. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
đ 	d 	Take the current cell's value, Subtract by 2, mod 17, Multiply by 3. 	Take the current cell's value, Add 2, mod 17, Divide by 3. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
Ĭ 	I 	Take the current cell's value, Add 4, Multiply 5. 	Take the current cell's value, Subtract 4, Divide by 5. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
ù 	u` 	Take the current cell's value, Divide by 4, Add 59. 	Take the current cell's value, Multiply by 4, Subtract 59. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
æ 	ae 	Add the current cell's value to the previous cell's value. 	Subtract the current cell's value to the next cell's value. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
ə 	e 	If this isn't the first instruction, Execute the previous instruction's reverse operation. 	Do nothing. 	None. 	None.
ą 	a, 	Take the current cell's value, Divide by 6 mod 17. 	Take the current cell's value, Multiply by 6, mod 17. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
Ą 	A, 	Grab a random number between 0 and 255. 	Same. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
ʑ 	z 	If the next cell's value is within the range 149 to 214, Execute the Ĭ instruction on the current cell and ą instruction on the previous cell and move to the previous cell. 	If the previous cell's value is not within the range 149 to 214, Execute the Ĭ instruction on the current cell and ą instruction on the next cel land move to the next cell.	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
♣ 	m 	Take the next instruction's index within this list and set the previous cell to it's index. 	Take the previous instruction's index within this list and the next cell to it's index. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
“ 	" 	Take the value of the next cell, multiply by 4, mod by the length of this list, execute the instruction at this index. 	Take the value of the previous cell, divide by 4, mod by the length of this list, execute the instruction in the list at this number. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
× 	x 	End the program. 	Same. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
ຯ 	4 	Take in input from user and get the index in the alphabet for the closest matching character (Blocking input, One character, Wait for player to input something that can be matched to a character): NUWYLSOEM IBD1H74GXP8AVT03JKR96ZF2CQ5 (The gap is intensional, 10 is space.)	Same, Except alphabet is in reverse. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
ǿ 	o` 	Take the value of the current cell, cycle every time it goes over 37 ((x-1 % 37) + 1), Grab the associated character from the alphabet and output: 26LHG15DZ83OCTNS9 KIFPVUJEB7W0MAQ4XYR (The gap is intensional, 18 is space.) 	Same, Except alphabet is in reverse. 	{Todo: Add pseudo-code} 	{Todo: Add pseudo-code}
=== Challenges ===
==== Hello, World! ====
 ĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬǿĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬǿĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬđǿǿĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬđđđđđđđđđđđđđǿĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬǿĬĬĬĬǿĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬǿĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬǿĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬĬǿĬĬĬĬĬǿ
Submitted by LyricLy using a program of her own creation which can be found in the External resources section.
 ĬəąǿĬùəąĬǿĬəąǿǿąùəǿĬđđǿĬəĬùǿĬəǿùĬǿùǿĬđəĬǿ
A much shorter version using a breadth-first brute force by Plokmijnuhby.
==== Non-Terminating Cat ====
 None.
==== Terminating Cat ====
 None.
==== Fibonacci Sequence ====
 None.
Note: The sequence must go up to 233, and you CANNOT hard-code any part of the sequence except the initial values of 1 and 1.
==== Print number in current cell/previous cell/next cell ====
 None.
 None.
 None.
==== Add the current cell to the previous cell/next cell ====
 None.
 None.
==== Subtract the current cell from the previous cell/next cell ====
 None.
 None.
==== Swap the next cell and previous cell/current cell and previous cell/current cell and next cell ====
 None.
 None.
 None.
==== Truth Machine ====
 None.
Note: It must take ignore all input except 0 and 1, if 0, print a zero and halt else print a 1 repeatedly and never halt.
==== Prove Turing-Completeness ====
I just re-read the article, and I think I understand it now. ʑə counts as one instruction, so you can't jump onto an ə.
I think the language is Turing complete now, because you should be able to program a Wang machine using unmarked as 130 and marked as 0. Why these numbers? Well, I was going to use 128 and 0, but it turns out some parts of the code are easier with multiples of 5.
M would be ąą. E could be ùùùùĬĬĬ.
L and R are slightly more complicated, as you need to ensure that moving left leaves a value between 149 and 214 behind you; ùđəĬ would work, as ʑ involves an additional Ĭ, so this would produce 195 for marked and 170 for unmarked. To undo the Ĭą, we must change 3 to 0 and 9 to 130, so this will require ĬąĬĬĬəĬą. A marked gap will be needed for jumps, so L would be ùđəĬʑùđəĬʑĬąĬĬĬəĬą. R will be required to convert from 15 to 0 and 11 to 130 (195 and 170 have had ą applied to them by this point) using đùəąĬąĬĬĬəĬ. R is therefore ʑđùəąĬąĬĬĬəĬʑđùəąĬąĬĬĬəĬ. Some edge cases: when you are moving left into the furthest left boundary, use ùđəĬʑùđəĬʑąą, and conversely when moving into the right boundary, use ʑąąʑąą. When moving away from a boundary, use ♣ or ♣ə to change the next cell to a usable value. If the current instruction's index is not suitable for this, use əə to wait around until it is. 
Performing a jump is more fiddly. We must move right with ʑąąą, then set the cell beneath us to the correct distance we want to jump (you'll have to write this part of the code yourself) then execute θə (or θ, if you so desire, but Wang machines are Turing complete without forward jumps). If the jump is too far, jump to a jump instruction nearer to the target instruction. If there is no code possible for the number you want - I have yet to encounter a number like this, but they may be out there - simply add əə's in between to change the required distance. After the θə, place the code ąąą to return to 0, then ùđəĬʑ. Immediately before the space you are jumping to, place ʑđùəąĬąĬĬĬəĬ as if you are about to make a jump, but do not place a θə. Immediately after the space, place ąąąùđəĬʑ as before. The net result should be that if you are passing through the label normally, no effect will occur, but if you jump to the label it will move you to the location required, correcting your value as you go.
And there you have it - full Turing completeness. That was harder than I expected.
--Plokmijnuhby (talk) 17:02, 18 May 2018 (UTC)
Inserted by Galaxtone (talk) 15:13, 24 Dec 2019 (UTC)
== External resources ==
* Brute Force Insane Text Generator by User:LyricLy.
* Javascript Brute Force Insane Text Generator by User:Galaxtone based on LyricLy's Brute Force Insane Text Generator.
Category:Languages Category:Turing complete