The entry into the Perl code contest works based on an eval() of a specific line of code, a pack() statement
and an eye deceiving algebra trick. 
The script opens a filehandle to itself and reads in every line. The last line of code prior to the subroutine
definitions is a call to a subroutine ( sub l ) that returns a value from an array ( @pe ). The line of code
containing the call to the subroutine is read in and evaluated against the code in the running script. This 
returns a number from within the array ( @pe ) that is a corresponding ASCII value for one of the characters
in 'The Perl Journal'. The line containing the subroutine is evaluated repeatedly with increasing numbers so
all the ASCII values in the 'The Perl Journal' are returned and stored in an array.
The array is built using subroutines that either clearly return a value or call another subroutine to help
calculate a return value or use some algebra to return the proper value, this is explained later.
To print 'The Perl Journal' in a human readable form the ASCII values need to be packed into a character array.
Just prior to the subroutine that returns the ASCII values is a 'print pack(pack...' statement. This will print 
the arrary ( @r ) in "C*" or multiple characters style. Packing ASCII code 67 and 42 to "C*" will produce the
characters 'C' and '*' for the first pack statement and the array ( @r ) contains the ASCII codes.
The first 'while' loop executes the code within enough times for every line of code to be read in and the 'sub l'
code to be execute enough times to produce all the characters in 'The Perl Journal'. This is where the algebra
trick is, and its used again in the code but its easilly spotted once the trick is known. (($ts*11)-(2*$ts))/($ts) 
looks like its doing some multiplys and divides based off a number given to it, in my case its the number of seconds
returned from 'localtime(time)'. If the math statement is written out on paper and algebraically reduced, the number
given to it has no bearing on the result. In the case of the math statement above, it will ALWAYS return 9, no matter
the value of '$ts'. I use this trick twice more, '(($ts*21)-(19*$ts))/($ts)' which always returns 2 and 
'(($p*31)-(21*$p))/($p)' which always returns 10. This is why I used 'localtime(time)' for the code, the odds that
the same number being returned from localtime everytime the script runs is very low and since that math 'ignores' the
value placed in it, I though it would be quite confusing if one did not notice the algebra.
Enough with the algebra review though. The 'unless' statement makes sure that the line of code that evaluates to an
ASCII value of 'The Perl Journal' executes only enough times to get all the characters. This 'unless' statement uses
the algebra described earlier. 
The position of the line of code to be evaluated from within the script is calculated by counting the number of lines
containing 'ub' characters and subtracting that off the size of the script. The characters 'ub' only appear like that
in the work 'sub' in the script.


