Madness

From Esolang
Jump to: navigation, search

Madness by User:PuzzleHunter84 uses 499 built-in instructions, 1 imaginary instruction that is rarely used, 3 1/2 memory spaces, a count that is limited to numbers that use only straight lines (1,4, and 7) and has its own version of general mathematics, a toggle, a timer, a three-sided polarity, a stack that has a mind of its own, loops that only run backwards, three variables, three wheels which work like those in Whirl and each have seven spaces, a deck of cards with two jokers, poker chips in five different colors (white, red, blue, green, and black), an interactive input, a potential input used only in case of emergency, a predetermined input that is not entirely known to humans, an output for each input, an output for the program, and recognises spaces, tabs, and new-lines as instructions, is case-sensitive, and water-resistant.

The 499 built in instructions and their functions are the following and are separated by commas but
 not spaces:

a  Pushes x onto the stack by the polarity where x is anything between a and (newline).  (Comma.
     pushes a ,)
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
`
~
-
_
=
+
!
@
#
$
%
^
&
*
(
)
[
]
{
}
|
\
/
?
.
Comma.
<
>
'
"
;
:
 (space)
     (tab)

(new line)
White plus   Adds one white chip to your poker stack.
Red plus  Adds one red chip to your poker stack.
Blue plus  Adds one blue chip to your poker stack.
Green plus  Adds one green chip to your poker stack.
Black plus  Adds one black chip to your poker stack.
Ante up.  Puts one white chip from your poker stack into the pot.
Small blind.  Puts one red chip from your poker stack into the pot.
Big blind.  Puts one blue chip from your poker stack into the pot.
Call.  Puts one green chip from your poker stack into the pot.
Raise.  Puts one black chip from your poker stack into the pot.
All in.  Puts all of your chips from your poker stack into the pot.
Double up.  The equivalent of an All in. followed by a Win your bet..
Win your bet.  Double the chips in the pot and move those chips to your poker stack.
Lose your bet.  Clear the pot.
Split the pot.  Add the chips in the pot to your poker stack.
Deal.  Place the top five cards face up on the table.
Shuffle.  Perform a “perfect shuffle” with the deck, where the top card does not change.
Cut.  Perform a “perfect cut” with the deck, a surplus card moving with the top card’s stack if
     necessary.
Look at your hand.  Start executing the cards on the table one card per nanosecond and discard each
     once executed.
Read ‘em and weep.  Execute all non-discarded cards on the table in order in one nanosecond.
Play some poker.  Initiate poker, allowing chips to be maneuvered and the deck to be handled.
Spin me!  Begin spinning me.
Spin you!  Begin spinning you.
Spin my red balloon!  Begin spinning my red balloon.
Spin us!  Begin spinning me and you.
Spin me and my red balloon!  Begin spinning me and my red balloon.
Spin you and my red balloon!  Begin spinning you and my red balloon.
Spin us and my red balloon!  Begin spinning me, you, and my red balloon.
Spin me the other way!  Reverse the spinning direction of me but not the speed.
Spin you the other way!  Reverse the spinning direction of you but not the speed.
Spin my red balloon the other way!  Reverse the spinning direction of my red balloon but not the
     speed.
Spin us the other way!  Reverse the spinning direction of me and you but not the speed.
Spin me and my red balloon the other way!  Reverse the spinning direction of me and my red balloon
     but not the speed.
Spin you and my red balloon the other way!  Reverse the spinning direction of you and my red
     balloon but not the speed.
Spin us and my red balloon the other way! Reverse the spinning direction of me, you, and my red
     balloon but not the speed.
Spin me faster!  Increase the spinning speed of me.
Spin you faster!  Increase the spinning speed of you.
Spin my red balloon faster!  Increase the spinning speed of  my red balloon.
Spin us faster!  Increase the spinning speed of me and you.
Spin me and my red balloon faster!  Increase the spinning speed of me and my red balloon.
Spin you and my red balloon faster!  Increase the spinning speed of you and my red balloon.
Spin us and my red balloon faster!  Increase the spinning speed of me, you, and my red balloon.
Spin me the other way faster!  Reverse the spinning direction and increase the speed of me.
Spin you the other way faster!  Reverse the spinning direction and increase the speed of you.
Spin my red balloon the other way faster!  Reverse the spinning direction and increase the speed of
     my red balloon.
Spin us the other way faster!  Reverse the spinning direction and increase the speed of me and you.
Spin me and my red balloon the other way faster!  Reverse the spinning direction and increase the
     speed of me and my red balloon.
Spin you and my red balloon the other way faster!  Reverse the spinning direction and increase the
     speed of you and my red balloon.
Spin us and my red balloon the other way faster!  Reverse the spinning direction and increase the
     speed of me, you, and my red balloon.
Stop spinning me!  Stop spinning me.
Stop spinning you!  Stop spinning you.
Stop spinning my red balloon!  Stop spinning my red balloon.
Stop spinning us!  Stop spinning me and you.
Stop spinning me and my red balloon!  Stop spinning me and my red balloon.
Stop spinning you and my red balloon!  Stop spinning you and my red balloon.
Stop spinning us and my red balloon!  Stop spinning me, you, and my red balloon.
Read me!  Execute the current instruction on me.
Read you!  Execute the current instruction on you.
Read my red balloon!  Execute the current instruction on my red balloon.
Wait 1 nanosecond then read me!  Execute the current instruction on me after 1 nanosecond.
Wait 1 nanosecond then read you!  Execute the current instruction on you after 1 nanosecond.
Wait 1 nanosecond then read my red balloon!  Execute the current instruction on my red balloon
     after 1 nanosecond.
Wait 2 nanoseconds then read me!  Execute the current instruction on me after 2 nanoseconds.
Wait 2 nanoseconds then read you!  Execute the current instruction on you after 2 nanoseconds.
Wait 2 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 2 nanoseconds.
Wait 3 nanoseconds then read me!  Execute the current instruction on me after 3 nanoseconds.
Wait 3 nanoseconds then read you!  Execute the current instruction on you after 3 nanoseconds.
Wait 3 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 3 nanoseconds.
Wait 4 nanoseconds then read me!  Execute the current instruction on me after 4 nanoseconds.
Wait 4 nanoseconds then read you!  Execute the current instruction on you after 4 nanoseconds.
Wait 4 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 4 nanoseconds.
Wait 5 nanoseconds then read me!  Execute the current instruction on me after 5 nanoseconds.
Wait 5 nanoseconds then read you!  Execute the current instruction on you after 5 nanoseconds.
Wait 5 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 5 nanoseconds.
Wait 6 nanoseconds then read me!  Execute the current instruction on me after 6 nanoseconds.
Wait 6 nanoseconds then read you!  Execute the current instruction on you after 6 nanoseconds.
Wait 6 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 6 nanoseconds.
Wait 7 nanoseconds then read me!  Execute the current instruction on me after 7 nanoseconds.
Wait 7 nanoseconds then read you!  Execute the current instruction on you after 7 nanoseconds.
Wait 7 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 7 nanoseconds.
Wait 8 nanoseconds then read me!  Execute the current instruction on me after 8 nanoseconds.
Wait 8 nanoseconds then read you!  Execute the current instruction on you after 8 nanoseconds.
Wait 8 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 8 nanoseconds.
Wait 9 nanoseconds then read me!  Execute the current instruction on me after 9 nanoseconds.
Wait 9 nanoseconds then read you!  Execute the current instruction on you after 9 nanoseconds.
Wait 9 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 9 nanoseconds.
Wait 10 nanoseconds then read me!  Execute the current instruction on me after 10 nanoseconds.
Wait 10 nanoseconds then read you!  Execute the current instruction on you after 10 nanoseconds.
Wait 10 nanoseconds then read my red balloon!  Execute the current instruction on my red balloon
     after 10 nanoseconds.
Snap.  Print the top value of the stack.
Crackle.  Change the top value of the stack from a numeral to an ASCII character and vice versa.
Pop.  Pop the top value on the stack if it is a non-numeral ASCII character.  
Snap and Crackle.  Change the top value of the stack from a numeral to an ASCII character and vice
     versa, then print it.
Snap and Pop.  Print the top value of the stack and pop if it is a non-numeral ASCII character.
Crackle and Pop.  Change the top value of the stack from a numeral to an ASCII character and vice
     versa, and pop if it is a non-numeral ASCII character.
Snap Crackle and Pop. Change the top value of the stack from a numeral to an ASCII character and
     vice versa, print it, and pop if it is a non-numeral ASCII character.
Start screaming.  Start the potential input sequence.
Scream louder.  Start frazzled skipping.
Scream at a lower pitch.  Asks specifically for an ASCII character in potential input.
Scream at a higher pitch.  Asks specifically for a numeral in potential input.
Scream "Emergency!"  Initiates Emergency mode for potential input.
Scream "This is not a drill!"  Initiates This is not a drill mode for potential input.
Scream "AAARGGHHH!"  Initiates AAARGGHHH mode for potential input.
Stop Screaming.  Stops the potential input sequence and outputs input if given.
Ask for the salt.  Asks for an ASCII character from stdin.
Ask for the pepper.  Asks for a numeral from stdin.
Ask for the salt or the pepper.  Asks for stdin.
Shake the salt.  Initiates shaking.
Shake the salt faster.  Increases shaking speed.
Shake the salt even faster.  Increases shaking speed to maximum.
Stop shaking the salt.  Stops shaking.
Grind the pepper.  Initiates grinding.
Grind the pepper faster.  Increases grinding speed.
Grind the pepper even faster.  Increases grinding speed to maximum.
Stop grinding the pepper.  Stops grinding.
Pass the salt.  Outputs salt input.
Pass the pepper.  Outputs pepper input.
Pass the salt or the pepper.  Outputs input where original value was unspecified.
Create a new timer.  Creates a new timer for immediately following instruction.
Set the timer to 1 nanosecond.  Sets the timer to 1 nanosecond.
Set the timer to 2 nanoseconds.  Sets the timer to 2 nanoseconds.
Set the timer to 3 nanoseconds.  Sets the timer to 3 nanoseconds.
Set the timer to 4 nanoseconds.  Sets the timer to 4 nanoseconds.
Set the timer to 5 nanoseconds.  Sets the timer to 5 nanoseconds.
Set the timer to 6 nanoseconds.  Sets the timer to 6 nanoseconds.
Set the timer to 7 nanoseconds.  Sets the timer to 7 nanoseconds.
Set the timer to 8 nanoseconds.  Sets the timer to 8 nanoseconds.
Set the timer to 9 nanoseconds.  Sets the timer to 9 nanoseconds.
Set the timer to 10 nanoseconds.  Sets the timer to 10 nanoseconds.
Set the timer to 11 nanoseconds.  Sets the timer to 11 nanoseconds.
Set the timer to 12 nanoseconds.  Sets the timer to 12 nanoseconds.
Set the timer to 13 nanoseconds.  Sets the timer to 13 nanoseconds.
Set the timer to 14 nanoseconds.  Sets the timer to 14 nanoseconds.
Set the timer to 15 nanoseconds.  Sets the timer to 15 nanoseconds.
Set the timer to 16 nanoseconds.  Sets the timer to 16 nanoseconds.
Set the timer to 17 nanoseconds.  Sets the timer to 17 nanoseconds.
Set the timer to 18 nanoseconds.  Sets the timer to 18 nanoseconds.
Set the timer to 19 nanoseconds.  Sets the timer to 19 nanoseconds.
Set the timer to 20 nanoseconds.  Sets the timer to 20 nanoseconds.
Start the timer.  Starts the timer.
Pause the timer.  Pauses the timer.
Stop the timer.  Stops the timer.
Reset the timer.  Resets, but doesn’t stop, the timer.
Shoot the timer with a shotgun and do it yourself.  Stops the timer, but initiates the instruction
     being timed immediately.
Become loopy.  Starts the end of the beginning of a loop.
Stop being loopy.  Ends the beginning of the end of a loop.
Decide to be loopy twice.  Designates that the loop will run twice.
Decide to be loopy thrice.  Designates that the loop will run thrice.
Decide to be loopy four times.  Designates that the loop will run four times.
Decide to be loopy five times.  Designates that the loop will run five times.
Decide to be loopy forever.  Designates that the loop will run forever.
Decide to be loopy as long as there’s a 1.  Designates that the loop will run if the count contains
     a 1.
Decide to be loopy as long as there’s a 4.  Designates that the loop will run if the count contains
     a 4.
Decide to be loopy as long as there’s a 7.  Designates that the loop will run if the count contains
     a 7.
Go to the North Pole.  Sets the polarity to north.
Go to the South Pole.  Sets the polarity to south.
Go to the Equator.  Sets the polarity to equatorial (neutral)
Flip the Earth upside-down.  Switches the polarity from north to south and vice versa.  Does
     nothing if the polarity is equatorial.
Look towards the heavens.  Initiates the predetermined input.
Scream towards the heavens.  Does something?
Throw stuff towards the heavens.  Angers the gods causing them to smite your stack.
Say this thing.  Pops a value from the stack and sets it to this thing.
Say that thing.  Pops a value from the stack and sets it to that thing.
Say the other thing.  Pops a value from the stack and sets it to the other thing.
Add this thing to that thing.  Adds this thing to that thing and pushes the result onto the stack
     resetting all three variables in the process.
Subtract this thing from that thing.  Subtracts this thing from that thing and pushes the result
     onto the stack resetting all three variables in the process.
Multiply this thing by that thing.  Multiplies this thing by that thing and pushes the result onto
     the stack resetting all three variables in the process.
Divide this thing by that thing.  Divides this thing by that thing and pushes the result onto the
     stack rounding down if necessary resetting all three variables in the process.
Take this thing to the power of that thing.  Takes this thing to the power of that thing and pushes
     the result onto the stack resetting all three variables in the process.
Take this thing modulo that thing.  Takes this thing modulo that thing and pushes the result onto
     the stack resetting all three variables in the process.
Add this thing to the other thing.  Adds this thing to the other thing and pushes the result onto
     the stack resetting all three variables in the process.
Subtract this thing from the other thing.  Subtracts this thing from the other thing and pushes the
     result onto the stack resetting all three variables in the process.
Multiply this thing by the other thing.  Multiplies this thing by the other thing and pushes the
     result onto the stack resetting all three variables in the process.
Divide this thing by the other thing.  Divides this thing by the other thing and pushes the result
     onto the stack rounding down if necessary resetting all three variables in the process.
Take this thing to the power of the other thing.  Takes this thing to the power of the other thing
     and pushes the result onto the stack resetting all three variables in the process.
Take this thing modulo the other thing.  Takes this thing modulo the other thing and pushes the
     result onto the stack resetting all three variables in the process.
Add that thing to the other thing.  Adds that thing to the other thing and pushes the result onto
     the stack resetting all three variables in the process.
Subtract that thing from the other thing.  Subtracts that thing from the other thing and pushes the
     result onto the stack resetting all three variables in the process.
Multiply that thing by the other thing.  Multiplies that thing by the other thing and pushes the
     result onto the stack resetting all three variables in the process.
Divide that thing by the other thing.  Divides that thing by the other thing and pushes the result
     onto the stack rounding down if necessary resetting all three variables in the process.
Take that thing to the power of the other thing.  Takes that thing to the power of the other thing
     and pushes the result onto the stack resetting all three variables in the process.
Take that thing modulo the other thing.  Takes that thing modulo the other thing and pushes the
     result onto the stack resetting all three variables in the process.
Fly the coop.  Move the value on top of the stack to the bottom.
Fly the coop backwards.  Move the value on the bottom of the stack to the top.
Fly the coop twice.  Move the value on top of the stack to the bottom then repeat.
Fly the coop twice backwards.  Move the value on the bottom of the stack to the top then repeat.
Fill the test tube with 1 mole of the solution.  Add 1 to the value in the test tube.
Fill the beaker with 1 mole of the solution.  Add 1 to the value in the beaker.
Fill the flask with 1 mole of the solution.  Add 1 to the value in the flask.
Fill the cardboard box with 1 mole of the solution and watch it slowly leak.  Add 1 to the value in
     the cardboard box and start the leaking process.
Fill the test tube with 2 moles of the solution.  Add 2 to the value in the test tube.
Fill the beaker with 2 moles of the solution.  Add 2 to the value in the beaker.
Fill the flask with 2 moles of the solution.  Add 2 to the value in the flask.
Fill the cardboard box with 2 moles of the solution and watch it slowly leak.  Add 2 to the value
     in the cardboard box and start the leaking process.
Fill the test tube with 3 moles of the solution.  Add 3 to the value in the test tube.
Fill the beaker with 3 moles of the solution.  Add 3 to the value in the beaker.
Fill the flask with 3 moles of the solution.  Add 3 to the value in the flask.
Fill the cardboard box with 3 moles of the solution and watch it slowly leak.  Add 3 to the value
     in the cardboard box and start the leaking process.
Fill the test tube with 4 moles of the solution.  Add 4 to the value in the test tube.
Fill the beaker with 4 moles of the solution.  Add 4 to the value in the beaker.
Fill the flask with 4 moles of the solution.  Add 4 to the value in the flask.
Fill the cardboard box with 4 moles of the solution and watch it slowly leak.  Add 4 to the value
     in the cardboard box and start the leaking process.
Fill the test tube with 5 moles of the solution.  Add 5 to the value in the test tube.
Fill the beaker with 5 moles of the solution.  Add 5 to the value in the beaker.
Fill the flask with 5 moles of the solution.  Add 5 to the value in the flask.
Fill the cardboard box with 5 moles of the solution and watch it slowly leak.  Add 5 to the value
     in the cardboard box and start the leaking process.
Fill the test tube with 6 moles of the solution.  Add 6 to the value in the test tube.
Fill the beaker with 6 moles of the solution.  Add 6 to the value in the beaker.
Fill the flask with 6 moles of the solution.  Add 6 to the value in the flask.
Fill the cardboard box with 6 moles of the solution and watch it slowly leak.  Add 6 to the value
     in the cardboard box and start the leaking process.
Fill the test tube with 7 moles of the solution.  Add 7 to the value in the test tube.
Fill the beaker with 7 moles of the solution.  Add 7 to the value in the beaker.
Fill the flask with 7 moles of the solution.  Add 7 to the value in the flask.
Fill the cardboard box with 7 moles of the solution and watch it slowly leak.  Add 7 to the value
     in the cardboard box and start the leaking process.
Fill the test tube with 8 moles of the solution.  Add 8 to the value in the test tube.
Fill the beaker with 8 moles of the solution.  Add 8 to the value in the beaker.
Fill the flask with 8 moles of the solution.  Add 8 to the value in the flask.
Fill the cardboard box with 8 moles of the solution and watch it slowly leak.  Add 8 to the value
     in the cardboard box and start the leaking process.
Fill the test tube with 9 moles of the solution.  Add 9 to the value in the test tube.
Fill the beaker with 9 moles of the solution.  Add 9 to the value in the beaker.
Fill the flask with 9 moles of the solution.  Add 9 to the value in the flask.
Fill the cardboard box with 9 moles of the solution and watch it slowly leak.  Add 9 to the value
     in the cardboard box and start the leaking process.
Fill the test tube with 10 moles of the solution.  Add 10 to the value in the test tube.
Fill the beaker with 10 moles of the solution.  Add 10 to the value in the beaker.
Fill the flask with 10 moles of the solution.  Add 10 to the value in the flask.
Fill the cardboard box with 10 moles of the solution and watch it slowly leak.  Add 10 to the value
     in the cardboard box and start the leaking process.
Empty the test tube.  Clear the value in the test tube.
Empty the beaker.  Clear the value in the beaker.
Empty the flask.  Clear the value in the flask.
Empty the cardboard box.  Clear the value in the cardboard box.
Empty the test tube on top of the stack.  Clear the value in the test tube and push that value onto
     the stack.
Empty the beaker on top of the stack.  Clear the value in the beaker and push that value onto the
     stack.
Empty the flask on top of the stack.  Clear the value in the flask and push that value onto the
     stack.
Empty the cardboard box on top of the stack.  Clear the value in the cardboard box and push that
     value onto the stack.
Empty the test tube into the pot and boil.  Clear the value in the test tube and print as an ASCII
     character.
Empty the beaker into the pot and boil.  Clear the value in the beaker and print as an ASCII
     character.
Empty the flask into the pot and boil.  Clear the value in the flask and print as an ASCII
     character.
Empty the cardboard box into the pot and boil.  Clear the value in the cardboard box and print as
     an ASCII character.
Activate the toggle.  Activate the toggle for 3 nanoseconds then deactivate.
Activate the toggle and run away yelling.  Activate the toggle until deactivated.
Toggle the toggle.  Toggle the toggle for 3 nanoseconds then toggle.
Toggle the toggle and run away yelling.  Toggle the toggle until toggled.
Deactivate the toggle.  Deactivate the toggle for 3 nanoseconds then activate.
Deactivate the toggle and run away yelling.  Deactivate the toggle until activated.
Joke around.  Initiate joker sequence then discard one joker.
Joke around twice.  Initiate joker sequence twice then discard both jokers.
Add 1.  Add 1 to the count via the chart below.
Add 4.  Add 4 to the count via the chart below.
Add 7.  Add 7 to the count via the chart below.
Subtract 1.  Subtract 1 from the count via the chart below.
Subtract 4.  Subtract 4 from the count via the chart below.
Subtract 7.  Subtract 7 from the count via the chart below.
Multiply by 1.  Multiply the count by 1 via the chart below.
Multiply by 4.  Multiply the count by 4 via the chart below.
Multiply by 7.  Multiply the count by 7 via the chart below.
Divide by 1.  Divide the count by 1 via the chart below.
Divide by 4.  Divide the count by 4 via the chart below.
Divide by 7.  Divide the count by 7 via the chart below.
Start from scratch.  Start executing instructions from the beginning of the program, but do not
     change anything else.
Start doing stuff.  Designates the start of the program.  Anything before is a comment.
Stop doing stuff.  Ends the program immediately.  
Throw the program in a puddle.  Ends the program immediately if the count contains a 1, 4, and 7.  
Throw the program in a bathtub.  Ends the program immediately if the count contains a 4 and 7.  
Throw the program in a pool.  Ends the program immediately if the count contains a 1 and 7.  
Throw the program in a river.  Ends the program immediately if the count contains a 1 and 4.  
Throw the program in a pond.  Ends the program immediately if the count contains a 7.  
Throw the program in a lake.  Ends the program immediately if the count contains a 4.  
Throw the program in the ocean.  Ends the program immediately if the count contains a 1.  
Put the count into the test tube and mix.  Mix the count but do not reset it and add it to the 
     value in the test tube.
Put the count into the beaker and mix.  Mix the count but do not reset it and add it to the value
     in the beaker.
Put the count into the flask and mix.  Mix the count but do not reset it and add it to the value in
     the flask.
Put the count into the cardboard box and mix and watch it slowly leak.  Mix the count but do not
     reset it and add it to the value in the cardboard box and start the leaking process if not
     already in progress.
Mix the count and stack it nicely on top.  Mix the count but do not reset it and push it on top of
     the stack.
Mix the count and snap.  Mix the count but do not reset it and print.
Mix the count and crackle.  Mix the count but do not reset it and change it to an ASCII character.
Mix the count and pop.  Mix the count but do not reset it and let it hang there.
Mix the count and snap and crackle.  Mix the count but do not reset it, change it to an ASCII
     character and print.
Mix the count and snap and pop.  Mix the count but do not reset it, print it, and let it hang there.
Mix the count and crackle and pop.  Mix the count but do not reset it, change it to an ASCII
     character, and let it hang there.
Mix the count and snap crackle and pop.  Mix the count but do not reset it, change it to an ASCII
     character, print it, and let it hang there.
Start the madness!  Starts the madness function.
Become madder!  Increases the madness.
Be as mad as possible!  Causes maximum madness.
Stop the madness!  Ends the madness function.

The imaginary instruction!  A nop used as a placeholder for time.

Functions
The 3 ½ memory spaces are called the test tube, the beaker, the flask, and the cardboard box.  They
 can all hold a numeral value known as the solution.  The cardboard box is special and “leaks”. 
 This means the solution decreases by 1 once every nanosecond (see Time below) until it reaches
 zero.  The count initializes at 1 and uses special math and rules when interacting with the
 output, the memory, and the stack:

count	1	4	7	11	14	17	41	44	47	71	74	77	111	114	117	141	144	147	171	174	177	411	414	417	441	444	447	471	474	477	711	714	717	741	744	747	771	774	777
+1	7	11	14	17	41	44	47	71	74	77	111	114	117	141	144	147	171	174	177	411	414	417	441	444	447	471	474	477	711	714	717	741	744	747	771	774	777	no	no
-1	no	no	1	4	7	11	14	17	41	44	47	71	74	77	111	114	117	141	144	147	171	174	177	411	414	417	441	444	447	471	474	477	711	714	717	741	744	747	771
*1	11	41	71	111	141	171	411	441	471	711	741	771	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no
/1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1
+4	11	14	17	41	44	47	71	74	77	111	114	117	141	144	147	171	174	177	411	414	417	441	444	447	471	474	477	711	714	717	741	744	747	771	774	777	no	no	no
-4	no	no	no	1	4	7	11	14	17	41	44	47	71	74	77	111	114	117	141	144	147	171	174	177	411	414	417	441	444	447	471	474	477	711	714	717	741	744	747
*4	14	44	74	114	144	174	414	444	474	714	744	774	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no
/4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4	4
+7	14	17	41	44	47	71	74	77	111	114	117	141	144	147	171	174	177	411	414	417	441	444	447	471	474	477	711	714	717	741	744	747	771	774	777	no	no	no	no
-7	no	no	no	no	1	4	7	11	14	17	41	44	47	71	74	77	111	114	117	141	144	147	171	174	177	411	414	417	441	444	447	471	474	477	711	714	717	741	744
*7	17	47	77	117	147	177	417	447	477	717	747	777	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no	no
/7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7	7

mix	10	32	48	49	50	51	52	53	54	55	56	57	65	66	67	68	69	70	71	72	73	74	75	76	77	78	79	80	81	82	83	84	85	86	87	88	89	90	127

“no” means that nothing happens otherwise the given value is produced.  The mix is used when
 transposing to output, the stack, or memory.

The toggle is used to change the poker instructions.  The toggle must be active for poker
 instructions to be followed and the instructions change if the toggle is toggled.  If you don’t
 run away yelling the action on the toggle will reverse after 3 nanoseconds (see Time below).The 
 3-sided polarity can be north (pos), south (neg), or equatorial (neutral) and determines what the
 singular symbol instructions do to the stack.  If the polarity is neutral the symbol is placed on
 top of the stack.  If the polarity is not neutral the ASCII value or numeral value (if it’s a
 number) is added to or subtracted from the ASCII value or numeral value (if it’s a number) of the
 top symbol of the stack and the result is put on the stack as a numeral.  The polarity initializes
 neutral.  The stack is used to contain an infinite amount of values and symbols.  Madness is used
 to mess up the stack.  If there is madness, the stack changes its top and bottom value(s) once
 every nanosecond (see Time below).  The madder the stack becomes the more values are swapped.  For
 example if there is a madness of 3 the top 3 and bottom three values on the stack reverse and
 switch once every nanosecond such that a stack of ye7Hc+./ would become /.+Hc7ey noticing that the
 H and c do not move.  If the stack is as mad as possible, the stack reverses completely once every
 nanosecond (see Time below).  The timer is used to set a timer on the next instruction
 after: “Create a new timer”.  The timer is then set to some amount of time between 1 and 20
 nanoseconds, and possibly starts.  If the time is paused the current time is saved until the timer
 is restarted.  Resetting the timer starts from the originally designated time but continues
 current start/pause setting.  Stopping the timer gets rid of it an forgets that it even existed.
 Shooting the timer with a handgun eliminates the timer and immediately executes the timed
 instruction.  If you become loopy, take heed of the next instruction, which will decide the
 condition or length of the loop.  If the condition is currently satisfied, find the first
 instruction therefore that stops the loopiness and begin executing instructions backwards starting
 there, as long as the condition is true at the end (beginning) of the loop, or for the specified
 number of times.  There are three wheels called: me, you, and my red balloon.  Me has functions
 that affect the position of values on the stack.  You has functions that affect the values on the
 stack.  My red balloon has functions that affect the count, polarity, toggle, and everything
 besides the stack.  They can be spinning at different rates that increment from one space every
 nanosecond to four spaces every nanosecond and can be spinning in either direction starting
 clockwise.  They all initialize at the nop space on each.  The functions are as follows:

Me:

Nop.
Swap the top two stack values.
Remove the second stack value from the top.
Remove the third stack value from the top.
Duplicate the top stack value.
Duplicate the second stack value from the top.
Duplicate the third stack value from the top.

You:

Nop.
Add the ASCII decimal values (if they are not integers) of the top two stack values, and push the
     result mod 127.
Subtract the ASCII decimal values (if they are not integers) of the top two stack values, and push
     the absolute value of the result mod 127.
Multiply the ASCII decimal values (if they are not integers) of the top two stack values, and push
     the result mod 127.
Divide the ASCII decimal values (if they are not integers) of the top stack value by the second
     stack value from the top, round down and push the result mod 127.
Divide the ASCII decimal values (if they are not integers) of the top stack value by the second
     stack value from the top, take the remainder and push the result mod 127.
Pop the top two stack values and push the one that’s ASCII decimal value (if they are not integers)
     is greater in value.

My Red Balloon:

Nop.
Reset the count to 1.
Go all in and lose your bet.
Toggle the toggle and run away yelling.
Flip the Earth upside-down.
Empty the test tube, beaker, and flask.
Empty the cardboard box.

The deck of cards is used to push certain values based on the toggle and the amount of poker chips
 in the chip stack.  In order for poker and card instructions to be applied, the toggle must be
 active.  In order for chips to be used, poker must be played.  The starting position of the cards
 in the deck facedown, top to bottom is how they appear in the chart.    The chart of pushed values
 is:


toggle/ off/    on/     off/    on/     off/    on/
chips   0-50    0-50	51-100	51-100	100+	100+
AH	1	2	3	4	5	6
2H	7	8	9	10	11	12
3H	13	14	15	16	17	18
4H	19	20	21	22	23	24
5H	25	26	27	28	29	30
6H	31	32	33	34	35	36
7H	37	38	39	40	41	42
8H	43	44	45	46	47	48
9H	49	50	51	52	53	54
TH	55	56	57	58	59	60
JH	61	62	63	64	65	66
QH	67	68	69	70	71	72
KH	73	74	75	76	77	78
AD	79	80	81	82	83	84
2D	85	86	87	88	89	90
3D	91	92	93	94	95	96
4D	97	98	99	100	101	102
5D	103	104	105	106	107	108
6D	109	110	111	112	113	114
7D	115	116	117	118	119	120
8D	121	122	123	124	125	126
9D	127	128	129	130	131	132
TD	133	134	135	136	137	138
JD	139	140	141	142	143	144
QD	145	146	147	148	149	150
KD	151	152	153	154	155	156
AC	157	158	159	160	161	162
2C	163	164	165	166	167	168
3C	169	170	171	172	173	174
4C	175	176	177	178	179	180
5C	181	182	183	184	185	186
6C	187	188	189	190	191	192
7C	193	194	195	196	197	198
8C	199	200	250	300	350	400
9C	450	500	550	600	650	700
TC	750	800	850	900	950	1000
JC	2000	3000	4000	5000	6000	7000
QC	8000	9000	10000	A	B	C
KC	D	E	F	G	H	I
AS	J	K	L	M	N	O
2S	P	Q	R	S	T	U
3S	V	W	X	Y	Z	a
4S	b	c	d	e	f	g
5S	h	i	j	k	l	m
6S	n	o	p	q	r	s
7S	t	u	v	w	x	y
8S	z	`	~	-	_	=
9S	+	!	@	#	$	%
TS	^	&	*	(	)	[
JS	]	{	}	|	\	/
QS	?	.	,	<	>	”
KS	’	;	:	(space)	(tab)	(new line)

The jokers are special and randomly take a card from the midst of the deck to read.  They are only
 played using “Joke around. (twice).”  Twice indicates this should be done for each joker.  After a
 joker is used it is discarded.  If both jokers have been used and you encounter a “Joke Around”
 instruction, ignore it.  After cards that are dealt are read, they are discarded.  The poker chips
 each have the following values:

White: 1
Red: 5
Blue: 10
Green: 20
Black: 50

If the salt or pepper is asked for, then an ASCII character or numeral is asked for from stdin
 respectively.  Shaking and grinding changes the value from numeral to character and vice versa
 once every 3 nanoseconds starting immediately, shaking/grinding faster/even faster speeds up the
 swapping process by one nanosecond each.  When and only when shaking/grinding is stopped, the
 resultant value is pushed onto the stack.  The potential input is done by screaming.  When
 screaming starts, an input is asked for but not necessary to continue the program normally.  When
 the screaming becomes louder, the program becomes frazzled and skips every other instruction until
 an input is given.  When “This is not a drill!” is screamed, the program executes the next
 instruction over and over until an input is given.  When “AAARGGHHH!” is screamed the program
 begins executing instructions backwards until an input is given, then returns to the instruction
 after ‘Scream “AAARGGHHH!”’ when an input is given.  When “Emergency!” is screamed, the program
 pauses until an input is given.  Screaming higher asks specifically for a numeral, and screaming
 lower asks specifically for a character.  “Stop screaming” stops the screaming and pushes the
 input, if one was given, onto the stack.  The predetermined input starts by the instruction “Look
 towards the heavens.”  Then either “Scream” or “Throw stuff” towards the heavens.  Screaming
 towards the heavens initiates a random input we think?  Or not?  We’re not sure.  Throwing stuff
 towards the heavens angers the gods and causes them to smite your stack, erasing all of the
 values.  This thing, that thing, and the other thing are variables.  When they are said a value is
 popped from the stack and set to that variable.  When math is done between two, all three reset (I
 know, annoying), and the result is pushed onto the stack.  The program is water-resistant to a
 point.  If the program is thrown into water it will stop processing if the count contains the
 given number(s).
  
Time:
Every instruction takes up one nanosecond of time to execute.  That’s it.

I hope you didn’t understand a word, because it will make me feel better that I don’t.