Took each letter of 'The Perl Journal' in order and extracted their ASCII
codes on paper. I then subtracted some constant to disguise them a little and
put these into an array. The array is stored in the @F array although some of its
members are added after the initialisation. Also some garbage values are added
onto the end and a couple of garbage values in the original data are
overwritten with good values later on.

Wrote a subroutine which takes one of these 'code' numbers and returns the
correct character. For a bit more disguise didn't use the correct codes for
spaces so detect these in the subroutine and override. This and the other
subroutine I made anonymous subs in the @F array.

A lot of the effort has gone into generating constants via routines, e.g.
wantarray will return 1 in an array context, so wantarray+wantarray will
return 2 in an array context and so on. Once you convert all these into their
constants things should become clearer.

We then iterate through the list of codes and apply the decoding subroutine to
them and print each letter in turn. When we get to the last code, i.e. the
second 'l' we die, but are caught in an eval block, which is called 'eval' and
print the final character using write. 

All the stuff following the final brace of the for loop is redundant since it
never gets executed, and the DATA is wholly spurious.

I added in numerous null ops all over the place, e.g. chomp, map, grep, etc to
pad things up to exactly 1000 chars and confuse matters.

The README may have been misleading on a couple of points. Of course the
program I<is> Y2K compliant and programs written using Turing complete
languages normally cannot be proven to terminate - not that either of these
points are the least bit relevant.
