Madness
Jump to navigation
Jump to 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.