
The obfuscation is divided into two (rather) distinct parts - the
string of subs where the program flow (hopefully) becomes rather
hard to follow, and the decryption process where the actual text
is obtained.

The program flow should be relatively easy to figure out on paper
or by writing out the code properly intended. Using the debugger
is not very helpful without modifying the code as it overwrites
DB::readline() which makes the debugger quit after the first command.
The 'gethostbyname' and 'use Socket' are simply used to mask the
true function - and to make the casual observer think that the code
blocks would actually be IP's.

sub's 1 - 5 are just used to mask the way (and order) in which
subs 6 and 7 are called - and to make it less than obvious where
the program even begins.

sub 6 implements a Feistel network decryption. The Feistel 
theorem is (shortly):

	Li = Ri-1
	Ri = Li-1 ^ f(Ri-1, Ki);

The decryption is simply the reverse of this. The f() I used is

	(K * Ri) % 256

There are 25 rounds of encryption for each block. The encryption
is not particulary strong but should be more than enough to prevent
anyone from decrypting the text without the code.

The encrypted text (blocks) is in the "IP's". There are three blocks,
each 8 chars wide, each block containing one of the required words.
The char 'b' was used to pad the blocks, so the original blocks
were "bbThebbb", "bbPerlbb", "Journalb", these converted into ord()
arrays and encrypted with the cipher described above.

sub6 attempts a brute force attack on the cipher to obtain the key used
in the encryption. As the keyspace is only 8 bits (to avoid US export
restrictions :-), the correct key (42) is found relatively quickly. After 
this the program resumes to open the encrypted blocks with the obtained key, 
and prints out the underlying text to stderr with die().

