From: wndalouise@aol.com (WndaLouise)
Newsgroups: comp.sys.hp48
Subject: The Most Evil Program -- Listing...!!!
Lines: 940
Message-ID: <1998062105301901.BAA06827@ladder03.news.aol.com>
NNTP-Posting-Host: ladder03.news.aol.com
X-Admin: news@aol.com
Date: 21 Jun 1998 05:30:19 GMT
Organization: AOL http://www.aol.com
Xref: republic.btigate.com comp.sys.hp48:12307

0123456789a123456789b123456789c123456789d123456789e123456789f12345678

----------------------------------------o
The Cabbage Codes
----------------------------------------o

by TinyWanda                                      wndalouise@aol.com
In conjunction with The BabyNous Cult                      June 1998

----------------------------------------o

The Cabbage Codes is a Directory of programs for the HP48g- which is based on
the work of others (?) that have explored the limits and potentials of what are
generically known as "God-Codes".
These God-Codes comprise a wide variety of methods to 'interpret', 'translate'
or 'decrypt'  texts, such as The Bible or other Sacred writings in such a way
that 'secret' messages are revealed...!!!

The Cabbage Codes, as a process toward this end, allows the User to create a
Cabbage Code; which is an Alphabet that has numerical values attached to each
letter, for any given Name or Phrase with a pre-selected sum.

That is;
The user selects a Name; such as:  "William Henry Gates III"
Then decides on a desired numerical sum, such as: 666
And The Cabbage Codes Directory of Programs will create an Alphabet with the
necessary numerical values, so that when the letters of the name are given the
values as defined by the Cabbage Code, and then added together, the resulting
sum will be the Desired numerical sum, i.e., 666.
The example below illustrates this effect.

William Henry Gates III

William Henry Gates III = 666

TheUnique-DivinelyRevealed-CabbageCode

A =  3   J = 29   S = 56   
B =  6   K = 32   T = 58   
C =  9   L = 35   U = 61   
D = 12   M = 38   V = 64   
E = 15   N = 41   W = 67   
F = 18   O = 44   X = 70   
G = 21   P = 47   Y = 73   
H = 23   Q = 50   Z = 76   
I = 26   R = 53

The second process/chore that -The Cabbage Codes- is capable of performing, is
to search through a body of text, while applying the just created Cabbage Code,
to find more words and phrases that sum to the primary numerical value, or any
number of other numerical values...!
In this example below, the text searched was Allen Ginsberg's; Howl.
The numerical values were, 95, 98, 666, 700 & 777
Each of these has either associations with either MicroSoft or the
JudeaChristianIslamic traditions for either extremiums of Evil or UnEvil.
The basic idea here is that these words/phrase should be interpreted as =Secret
Messages= that are Revealed by The Divinely Inspired Cabbage Code...!!!

Also:
Since the resulting sums are determined independently of sequence, the user is
allowed to freely rearrange the words to achieve the most damning effect, or
should they have the appropriate software or patience, Rearrange the letters to
form interesting alternative anagrams...!

Also, also: This example listing below is the complete unedited listing
produced by The Cabbage Code Directory.  
What i find especially interesting from this 'process' is how very few
'discoveries' are utterly & completely meaningless...as opposed to simply
baffling...!!!
...almost all of these, with only a small amount of rearranging, will produce a
perfectly viable haiku-like sentence fragment that should allow the reader to
interpret from it, whatever conclusions they are vulnerable to make...!!! (?)

-----------------------------------
Set Of 95's
Ended                       = 95

Set Of 98's
                                    ( no matches found )

Set Of 666's
AndImmortalItShould         = 666
TheWildEyes!TheHoly         = 666
Years.IiWhatSphinx          = 666
IngPlane,WhoDreamtAndMade   = 666
Imaginary,NothingButA       = 666
Habit,OrRockyMount          = 666
Denver,WhoDiedInDenver,     = 666
Saic,LeapedOnNegroes,Cried  = 666
Editors,OrWereRun           = 666
DocksWaitingForADoor        = 666
FamiliarRoadsideLonely      = 666
NakedInTheLake,WhoWent      = 666
OfBickford'sFloatedOut      = 666
LightOfBickford'sFloated    = 666

Set Of 700's
TheHighwayAcrossAmerica     = 700
NeverReturnYour             = 700
LongerAdmitTheWorms         = 700
InRocklandWhereYour         = 700
WithTheAbsoluteHeart        = 700
ShadowOfTheBandAndBlewThe   = 700
SayInTimeComeAfterDeath,    = 700
AWireHangerInTheCloset,     = 700
Rock-IngAndRollingInThe     = 700
YearsLaterTrulyBald         = 700
LonesomeForHerHeroes,       = 700
ActuallyHap-PenedAndWalked  = 700
BarnsAndNakedInTheLake,Who  = 700
ForCommittingNoCrime        = 700
AndUndressingWhileThe       = 700
AndSoTookShipToAfrica,      = 700
IdahoSeekingVis-Ionary      = 700
ForTheEndlessRideFrom       = 700
AngelsStaggeringOnTene-     = 700

Set Of 777's
AgainFromItsPilgrimageToA   = 777
Hydrogen!MolochWhoseName    = 777
Tomb!MolochWhoseEyesAreA    = 777
PoemOfLifeButcheredOutOf    = 777
JumpingWithSensation        = 777
InTheTotalAnimalSoupOf      = 777
PilgrimState'sRockland's    = 777
OnTheirKneesInHopeless      = 777
AllOverTheStreet,DancedOn   = 777
ForADoorInTheEastRiver      = 777
VastSordidMovies,Were       = 777
FateTheOneEyedShrewOfThe    = 777
ThreeOldShrewsOfFateThe     = 777
TheThreeOldShrewsOfFate     = 777
InRoseGardensAndTheGrass    = 777
AHopelessTask,AndSoTook     = 777
Bickford'sFloatedOutAndSat  = 777
WhoWereExpelledFromThe      = 777
AtDawnLookingForAnAngry     = 777

According to traditional =CodeGodTheory=, these codes will =Only= work when
applied to The Bible or some other Sacred texts, and consequently, allow
themselves to be tested according to the basic premise inclusive to The
Scientific Method...!!!
That is; With traditional GodCode procedures &/or alphabets, if the process is
used on a profane/secular/heretical book or text, then NO meaningful secret
messages will be revealed...!!!

Regretfully...!!!...The Cabbage Codes assert that the codes that it produces
will work on ANY text, specifically asserting; that, 'Who but The Great
Cabbage, ( Of Whom No Greater Cabbage Can Be Imagined ) could succeed so
elegantly/successfully in inserting secret messages into every imaginable text
ever produced...!!! 
This effect; more than any other, should strike the examiner as irrefutable
proof that this effect is a genuine technique for revealing the true and
undeniable word of The Great Cabbage...!!!

Consequently; The Cabbage Codes do allow themselves to be 'tested' by skeptical
heretics. The Cabbage Codes are above the infantile 
hen-scratching that allegedly learned men would use to examine the
undergarments and subtle thoughts of The Great Cabbage...!
Such fe/men will have to wait until their time here, amoung the pathetic
dimensional illusions of reality, are spent, to learn what feeble-minded fools
they've been.

And so on.

--------------------------------------------------------o

The Cabbage Codes :: The Directory
--------------------------------------------------------o

The Directory consists of:
                 This is an OverView of the Directory Contents,
  Below this OverView is a Complete Explanation of Each Object.

.666.      The Directories Name

Characters Note:
      Not all the Characters that are depicted here are 
      the actual Characters used in the actual directory.
      Such as; in .666. ( . = CHR(183) )
      Examine the actual directory in the 48 to determine 
      which Ascii Names refer to which 48 Names.
      The list here is in the order that they appear on 
      the 48.

User Access Programs

SetUp      PreStart, Fill in the Blanks, Jumps to Start.
Start      Create the Cabbage Code.
Make       Search Text for Numerical Matches.
Chek       What is the Numerical Value of a String?

Local SubRoutines

Save       Save something into a Unique label.
Text       Directory of texts to Search with Make.
A1         Template Alphabet.
Fin        Creates a Formatted Cabbage Code Listing.
Fin2       Creates a Formatted Listing from Make.
1Caps      Capitalizes the first letter of each word in a string.
Do.Gc      Creates the Cabbage Code. 
Freq       Creates a list of frequency values for a string.
Poff       Picks off the first word of a string.
.^?^.      Determines what's on the stack.

Global SubRoutines

Abc        Converts Base 10 to Base 26.
Cba        Inverse of Abc.
Alrm       Sounds an Alarm.
Blink      Blinks the display.
Caps       Converts a string to all Capitals.
>Gap       Creates a blank string of a specified length.
Pos2       Like POS, but returns all matches in a string or list.

Variables

.>a        Reference for Abc & Save.
Name       Global save of selected name or phrase.
key        Primary numerical value to be attached to Name.
>?<        List of Secondary Numerical Values.
>gc<       List of Cabbage Code values.

Interrupt Variables
If 'Make' is interrupted while it is running, these global variables are
retained to save the strings & their accompanying values that were found up to
that point.

Omega     List of found numerical matches.
Beta      List of Strings currently being evaluated.
Epsilon   List of numerical values for Beta.

----------------------------------------------------o

How to Use Each of the Relevant Programs:
---------------------------------------------::
--------------------------------------::
SetUp
SetUp is the real Starting program...
It consists of an Inform prompt that asks you for the initial values that the
program is then going to work with.
Name:    The Name or Phrase that you want to affix a
         Numerical Value to.
Target:  The Numerical Value that you want the Name to equal.
Find:    These are the Numerical Values that you're going to
         search for in the block of text to be defined later.
Temp:    This is the Template that you use to create the sequential
         properties of the Cabbage Code.

All the Default Values that appear when the Inform is executed, are pulled from
the Global Variables that will store any new values.

The Temp ( Cabbage Code Template ) is interesting in that this list of 26
numerical/integer values can have any value at all...you can arrange them
according to any numerical sequence or assign them random values.
The purpose of the Temp ( Stored in 'A1' ) is to create an initial Cabbage Code
which is then determined to deviate from the desired Cabbage Code by 'x'
amount, and then corrected to that degree...! 

After you've entered all the desired values, hit OK.

The display then scans through the alphabet, 
Blinks the screen, & returns a string of the form;
"Name = Target"
As confirmation that the Cabbage Code is working properly.

The Desired Cabbage Code is Stored in >gc<, at the end of the Directory Menu.
All other programs and effects will pull this list up as it is needed.

--------------------------------------::
Start
This is the Raw version of SetUp & can be used alone, by either just hitting
'Start' with anything except a string on 1:, in which case, the necessary
string that it needs will be pulled from the Global Variable 'Name'.
Or---
The User can load the desired String Name on 1: and 'Start' will use it to
create a new Cabbage Code, from the target value stored in 'key', and then
store the new Cabbage Code in >gc<.

You might want to use this instead of Setup, if, all other things being equal,
you want to input a variation on the desired Name...???

--------------------------------------::
Make
This is the Other Big Program. ( Aside from SetUp )
When you hit 'Make' it will Prompt/Remind you that a comparatively large block
of text is needed on 1:.
Input is:
1:  "A Large Block of Text"
This block of text should already be on 1: before you hit 'Make', and then when
it prompts you for it, you'll simply hit ENTER.

The block of text could be a poem, and short story, a collection of verses from
The Bible, Koran, Torah or the Tao Te Ching...or a news item, a collection of
news items, a songs lyrics, a scientific article, a compilation of Email,
or...(?)...whatever.
Something with lots of interesting words &/or phrases.

To get this block of text into your HP48;
Transfer the block of text on your computer to a PlainText document,
Then prefix it, (type or Paste) at the very top of the document, 
with this header;
  %%HP: T(1)A(D)F(.);
  C$ $

Note that the T(type) is (1).
This will preserve all the characters in their true form, and translate the
somewhat anomalous HP48's use of CHR(10) as a carriage return to the CHR(13)
that your computer uses, and vice versa.

Set you HP48 Preferences to this setting by;
Hitting the Blue/Right I/O [1] key,
Then selecting 'Transfer' from the Choose Menu,
Then changing XLAT to New1 ( the second item in that Choose Menu ),
Then NXT to the next menu, and hit OK.

Anyway...
After you've put the block of text on 1: and hit 'Make', ENTER.
& Go find something else to do for several hours.

It also might be a good idea to put fresh batteries in before starting this
program...
...it is very very VERY slow...!!!

You'll get a 'countdown' displayed on the screen to assure you that it's doing
SomeThing...But the amount changes very slowly...!!!...as words are taken off
the block of text, connected to each other, and tediously compared with the
Cabbage Code to see if any of the combinations look interesting according to
the secondary target list that you've provided.

Finally...!
After the whole text has been thoroughly searched, the results are neatly
formatted and stored under a unique name that should be found at the beginning
of the Directory menu.

If 'Make' is interrupted with [ON] before it's finished, the accumulated
results up to that point can be found in the Omega Variable.

--------------------------------------::
Chek
Check to see what the numerical value of any given string is, 
according to the Cabbage Code stored in >gc<.
Input is  1:          "String"
Output is 2: "Original String" 
          1:     Numerical Sum

--------------------------------------::
Save
Saves any object on 1: into a unique Global Variable.
Input is:
1:    Any Object
'Save' prefixes the variable name with '.->' and uses the value in .->a & the
program 'Abc' to create an Alphabetic Sequence that is Incremented after each
use of 'Save'.

This program is kind of useful to save any given item without having to burden
yourself with thinking up a name for it...!
Use RightShift/VIEW to find the desired item later on...!

--------------------------------------::
Text
Text is a Directory that The User may use to store comparatively large
text-files for later use with 'Make'.

--------------------------------------::
A1
This is the Template of the AlphaNumerical Values used to create the initial
Cabbage Code.
This list consists of any 26 Integer Values.
The sequence of values may or may not have any particular order to them.

--------------------------------------::
Fin
This Creates the Neatly structured layout of the Name, and it's accompanying
Cabbage Code which is used to produce the Names desired Target Value.
Fin Requires no Input, All Values are taken from their Global Variables.
Output is a String suitable for printing in a MonoSpatial Font.

--------------------------------------::
Fin2
This Creates the Neatly structured layout of the found words & phrases
discovered in the block of text by 'Make'.
Input is the Omega List Created by Make.
1:  { { "SecretMessage" NumericalValue } ... }
Make automatically executes Fin & Fin2 after it's created the Omega List and
attaches the two together into a single string---if it's allowed to run to it's
natural termination sequence.
Output is a String suitable for printing in a MonoSpatial Font.

--------------------------------------::
1Caps
1Caps takes a string of a single word or a group of words, and Capitalizes the
first letter of each word, while converting all other characters to lowercase.
Input is:  1:  "String of words"
Output is: 1:  "String Of Words"

--------------------------------------::
Do.Gc
This is the magick bits...!
Do GodCode produces the desired God/Cabbage Code from the Frequency List
created by 'Freq' and the Target Value stored in 'key'.
Input is:    1:    { Frequency List }
Output is:   2:    { Frequency List }
             1:      { Cabbage Code }

--------------------------------------::
Freq
Frequency creates a List of numerical values which represent the number of
times each letter occurs within a string provided to it.
Input is:      1:                "String"
Output is:     2:       "Original String"
               1:   { 0 0 0 0 0 0 1 0 ...

--------------------------------------::
Poff
Picks off the first word of a string, as defined by the first clump of
characters that occur until a space or carriage return is encountered.
It also returns the original string without the word that was just picked off.
Input is:    1:    "String of words"
Output is:   2:           "of words"
             1:             "String"

--------------------------------------::
.^?^.
What is on the stack, if anything?
Input is:    1:  { List of Object Types from top to bottom }

The output is either a 1, if those object types were in fact on the stack in
that order, 
or; 0 if they were not.

Output       1:   1/0
   
--------------------------------------::
Abc
Converts a Base 10 integer number into a Base 26 A-Z number.
Input is:     1:    Base 10 Integer Number
Output is:    1:  "Base 26 Integer Number"

14  =  "N"
238 = "ID"
666 = "YP"

--------------------------------------::
Cba
'Cba' is the Inverse of 'Abc'

"CABBAGE" = 939579671

--------------------------------------::
Alrm
Sounds a unique alarm each time it's executed.
To Stop the Alarm without incurring any penalties, 
Simply hit [ON]

--------------------------------------::
Blink
Blinks the screen, and beeps a unique pattern of blinks/beeps each time it's
executed.

--------------------------------------::
Caps
Converts a string to All Caps and removes any characters that are Not Capital
letters.
Input is:    1:   "String of words &/or Symbols, 123"
Output is    1:              "STRINGOFWORDSORSYMBOLS"

--------------------------------------::
->Gap
Creates a string of spaces from a specified amount.
Input is:    1:     Real Amount
Output is:   1:         "     "  Gap of that amount

--------------------------------------::
Pos2
Works just like POS, Except that it returns a list of all the occurrences
within the searched String or List.

--------------------------------------::
.->a
Variable used by Abc & Save

--------------------------------------::
Name
"Name, Word or Phrase" to be linked by The Cabbage Code to the amount specified
in 'key'.

--------------------------------------::
key
The target value that The Cabbage Code is created, in order that that amount is
the sum of the string in 'Name'.

--------------------------------------::
>?<
The List of values to be used by Make while searching a block of text.

--------------------------------------::
>gc<
The Cabbage Code.

--------------------------------------::

--------------------------------------------------o

The Cabbage Codes Directory; Listing in T(3)

Name:        .666.    ( the pre/aff/ix dots are actually CHR(183) )
CheckSum:  # ADEDh
Size:         5334

----cut-here----------------------------------------------o

%%HP: T(3)A(D)F(.);
DIR
  SetUp
    \<<
"The Great Cabbage"
{ { "Name"
"Word or Phrase" 2
} { "Target"
"Key / Fabrication Value"
0 } { "Find  "
"Secondary / Search Values"
5 } { "Temp"
"Initiating / Template Alphabet"
5 } } { } {
"The Pope" 666 {
666 700 777 } } A1
1 \->LIST + Name key
\->?\<- A1 4 \->LIST
INFORM
      \<< { Name key
\->?\<- A1 } STO Start
      \>>
      \<<
"Input Termination"
DOERR
      \>> IFTE
    \>>
  Start
    \<< { 2 } :&:
\183\|^?\|^\183 EVAL
      \<< DUP 'Name'
STO
      \>> 'Name' IFTE
:&: Freq EVAL Do\183Gc
DUP2 2
      \<< *
      \>> DOLIST
\GSLIST key SWAP -
DUP
      \<< \-> \Gd
        \<< OVER \Gd
ABS POS DUP
          \<< DUP2
GET \Gd SIGN + PUT
SWAP DROP
          \>>
          \<< DROP
SWAP 1 :&: Pos2
EVAL DUP SIZE
            \<< DUP
SIZE \-> \Ga \Gb
              \<< 1 \Gd
ABS
START \Ga \Gb RAND *
CEIL GET DUP2 GET \Gd
SIGN + PUT
NEXT
              \>>
            \>>
            \<< DROP2
"Ugh!!!
TryChangingSlightly"
DOERR
            \>> IFTE
          \>> IFTE
        \>>
      \>>
      \<< ROT DROP2
      \>> IFTE '\->gc\<-'
STO Chek " = " SWAP
+ + :&: Bl\161nk EVAL
    \>>
  Make
    \<<
C$ 15 1: "SearchText"
"" INPUT OBJ\-> CLLCD
{ { } { } { } } { \Ge
\Gb \GW } STO \->?\<- DUP
SIZE GET \-> \|^
      \<<
        WHILE DUP
SIZE DUP 3 DISP
        REPEAT :&:
Poff EVAL :&: \185Caps
EVAL Chek \-> \162 \pi
          \<< \pi
            \<< \Gb
SIZE
              \<< 1 \Gb
SIZE
FOR \GD '\Gb' \GD DUP2
GET \162 + PUT '\Ge' \GD
DUP2 GET \pi + PUT
NEXT
              \>> IFT
'\Gb' \162 STO+ '\Ge' \pi
STO+ { } { } 1 \Gb
SIZE
              FOR \.V
'\Gb' \.V GET '\Ge' \.V GET
DUP \|^ >
\<< DROP2
\>>
\<< 4 ROLL 3 PICK + 4
ROLLD ROT OVER + 3
ROLLD \->?\<- OVER POS
  \<< 2 \->LIST 1 \->LIST
'\GW' STO+
  \>>
  \<< DROP2
  \>> IFTE
\>> IFTE
              NEXT
'\Ge' STO '\Gb' STO
            \>> IFT
          \>>
        END DROP \GW
{ \GW \Gb \Ge } PURGE F\161n
SWAP DUP SIZE
        \<< F\161n\178 +
        \>>
        \<<
"NullSearch" \->TAG
SWAP
        \>> IFTE Save
:&: Alrm EVAL
      \>>
    \>>
  Chek
    \<< DUP :&: Caps
EVAL DUP SIZE
      \<< 0 1 3 PICK
SIZE
        FOR $ OVER
$ $ SUB NUM 64 -
'\->gc\<-' SWAP GET +
        NEXT SWAP
DROP
      \>>
      \<< DROP 0
      \>> IFTE
    \>>
  Save
    \<< "\183\->" '\183\->\Ga'
INCR :&: Abc EVAL +
OBJ\-> STO
    \>>
  Text
    DIR
    END
  A1 { 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 }
  F\161n
    \<< \->gc\<- 0 1 26
      FOR $ OVER $
GET \->STR SIZE DUP2
< :: SWAP IFT DROP
      NEXT SWAP
DROP 10 CHR \-> z \|v
      \<< \->gc\<- 0 + \|v
Name \|v \|v + + + Name
" = " key + + \|v \|v +
+
"TheUnique-DivinelyRevealed-CabbageCode"
\|v \|v + + + + 0 8
        FOR $ 0 2
          FOR \162 $ \162
9 * 1 + + DUP 64 +
CHR " = " + 4 PICK
ROT GET \->STR z OVER
SIZE - :&: \->Gap
EVAL SWAP "   " + +
+ +
          NEXT \|v +
        NEXT SWAP
DROP 1 OVER "[" POS
4 - SUB \|v \|v + +
      \>>
    \>>
  F\161n\178
    \<< 0 1 3 PICK
SIZE
      FOR $ OVER $
GET 1 GET SIZE DUP2
< :: SWAP IFT DROP
      NEXT :&: \->Gap
EVAL DUP SIZE 10
CHR \-> \183\173\183 z \|v
      \<< \->?\<- DUP
SIZE { }
        WHILE SWAP
DUP
        REPEAT DUP
1 - SWAP 4 PICK
SWAP GET "'s" +
"Set Of " SWAP \|v +
+ ROT +
        END DROP 1
4 PICK SIZE
        FOR $ 3
PICK $ GET EVAL \-> a
b
          \<< OVER b
POS DUP2 GET a z
OVER SIZE - :&:
\->Gap EVAL "  = " b
\|v + + + + + PUT
          \>>
        NEXT 3
ROLLD DROP2 OBJ\-> 2
SWAP
        START \|v
SWAP + +
        NEXT
      \>>
    \>>
  \185Caps
    \<< DUP SIZE 0
RCLF \-> $ z ? f
      \<< STD 1 z
        FOR \GD $ \GD
DUP SUB NUM \-> \pi
          \<<
            CASE \pi
65 \>= \pi 90 \<= AND
              THEN
? 1 ==
\<< \pi 32 + 1
\>>
\<< 1 '?' STO 0
\>> IFTE
              END \pi
97 \>= \pi 122 \<= AND
              THEN
? 0 ==
\<< \pi 32 - 1 '?' STO
1
\>> 0 IFTE
              END \pi
32 ==
              THEN
0 '?' STO 0
              END 0
            END
            \<< CHR $
\GD ROT REPL '$' STO
            \>> IFT
          \>>
        NEXT $ f
STOF
      \>>
    \>>
  Do\183Gc
    \<< DUP A1 2
      \<< *
      \>> DOLIST
\GSLIST SWAP key ROT
/ "\<< \-> \Ga \<< \Ga " SWAP
" * 0 RND \>>\>>" + +
OBJ\-> A1 SWAP DOSUBS
    \>>
  Freq
    \<< CLLCD DUP :&:
Caps EVAL { } 65 90
      FOR $ OVER $
CHR "  " OVER + 3
DISP :&: Pos2 EVAL
SIZE +
      NEXT SWAP
DROP
    \>>
  Poff
    \<< DUP " " POS
OVER 10 CHR POS 2
\->LIST DUP 0 POS DUP
      \<< 1 - NOT 1 +
GET
      \>>
      \<< DROP EVAL
MIN
      \>> IFTE DUP
      \<< OVER 1 3
PICK 1 - SUB 3
ROLLD 1 + OVER SIZE
SUB SWAP
      \>>
      \<< DROP ""
SWAP
      \>> IFTE
    \>>
  \183\|^?\|^\183
    \<< DUP SIZE \-> p
q
      \<< DEPTH q \>=
        \<< { } 1 q
          START
SWAP DUP TYPE SWAP
q 2 + ROLLD SWAP +
          NEXT p ==
        \>> 0 IFTE
      \>>
    \>>
  Abc
    \<< ""
      WHILE OVER 26
>
      REPEAT OVER
26 SWAP 1 - SWAP
MOD 1 + DUP 64 +
CHR EVAL ROT + 3
ROLLD - 26 / SWAP
      END SWAP 64 +
CHR EVAL SWAP +
    \>>
  Cba
    \<< DUP SIZE \-> \162
      \<< 0 1 \162
        FOR $ OVER
$ $ SUB NUM 64 - 26
\162 $ - ^ * +
        NEXT SWAP
DROP
      \>>
    \>>
  Alrm
    \<< -56 CF DEPTH
\->LIST RAND 6 * 2 +
CEIL \-> h y
      \<<
        IFERR { } 1
y
          START
RAND 4400 * + RAND
+
          NEXT 1 8
          START DUP
EVAL 1 y
            START
BEEP
            NEXT
          NEXT
        THEN
        END CLEAR h
OBJ\-> DROP -56 SF
      \>>
    \>>
  Bl\161nk
    \<< RCLF -56 CF
PICT RCL LCD\-> PICT
STO { # 0d # 0d }
PVIEW 1 RAND 9 *
CEIL
      START PICT
NEG RAND 3000 * 500
+ .07 BEEP
      NEXT TEXT
PICT STO STOF
    \>>
  Caps
    \<< "" 1 3 PICK
SIZE
      FOR \pi OVER \pi
DUP SUB NUM \-> \|v
        \<<
          CASE \|v 65
<
            THEN ""
            END \|v
91 <
            THEN \|v
CHR
            END \|v
97 <
            THEN ""
            END \|v
123 <
            THEN \|v
32 - CHR
            END ""
          END
        \>> +
      NEXT SWAP
DROP
    \>>
  \->Gap
    \<< ""
      WHILE SWAP
DUP
      REPEAT 1 -
SWAP " " +
      END DROP
    \>>
  Pos2
    \<< { } \-> $ \162
      \<<
        WHILE DUP $
POS DUP
        REPEAT \162
SIZE
          \<< DUP '\162'
1 GET +
          \>>
          \<< DUP
          \>> IFTE
'\162' STO+ 1 + MAXR
\->NUM SUB
        END DROP2 \162
REVLIST
      \>>
    \>>
  \183\->\Ga 0
  Name
"TeleTubbies"
  key 666
  \->?\<- { 666 700 777
}
  \->gc\<- { 6 11 17 22
28 33 39 44 49 56
61 67 72 78 83 89
94 100 105 111 117
122 128 133 139 144
}
END

-[ TERMINUS ]-