#!/usr/bin/perl -wire
# sets -w, which only tries to slightly obfuscate that i'm using -i ( $^I) to
# hold "re".  a later version of this, i added a comment below this line that
# read "# Just another Bird onawire", hoping that an observant deobfuscator
# would notice that that phrase contained most of "Just another Perl hacker,",
# had the right capitalization, and the correct number of characters, and lead
# the deobfuscator to believe that the comment might be used to generate the
# phrase.

# set $/ to 'J' to create the capital J.
$/ = "J";

# set $\ (output record separator, saves from having to print it) to ',' for
# the end of the japh.
$\ = ",";

# some basic character -> ord -> math -> character machinations.
# this puts the string "kcahtona" into $r - those bits give "anoth" and "hack"
# when reversed and substr'd out.
$r = join "",
     map { $_ += 57; chr }
     map { ord }
     split //, "2*(/;65(";

# t holds a list of single character symbols in the symbol table.
@t = sort
     map { if( m/^\w$/m ){
             $_
           }
         }
     keys %{ *:: } ;

# sub u returns a single space.
sub u { $" }

# sub s returns "re" . "htona" = "another" reversed.
sub s { $^I . substr $r, 3, 5 }

# sub j returns "l" . "re" . "P" = "Perl" reversed.  i've learned that the
# symbol table gets populated in a reliable manner (at least reliable enough
# for the purposes of this JAPH) to be able to count on the position in a sorted
# list of single character symbol table entries.
sub j { $t[-5] . $^I . $t[-8] }

# sub P returns "re" . "kcah" = "hacker" reversed.
sub P { $^I . substr $r, 0, 4 }

# sub l returns "t" . "s" . "u" . "J" = "Just" reversed.
sub l { $t[-2] . $t[-3] . $t[-1]. $/ }

print map {
            # this just adds a space (via sub u) after every word-returning
            # subroutine unless it matches /ack/.
            if( m/ack/ ){
              $_
            }
            else {
              $_ .= &u  }
          }
      # calls the subroutines in order, reversing the letters in each word.
      map { scalar reverse }
          ( l, &s, &j, &P);

##</code><code>##

$/="J";$\=",";$r=join""=>map{$_+=57;chr}map{ord}split//=>"2*(/;65(";@t=sort
map{if(m*^\w$*m){$_}}keys%{*::};sub u{$"}sub s{$^I.substr$r,3,5}sub j{$t[-5].$^I
.$t[-8]}sub P{$^I.substr$r,0,4}sub l{$t[-2].$t[-3].$t[-1].$/}print map{if(m#ack#
){$_}else{$_.=&u}}map{~~reverse}(l,&s,&j,&P);

##</code><code>##

#!/usr/bin/perl -wire

$_=q|$/="J"; $\=","; $s=kpjo"",nbq{$_+=79;dis}nbq{pse}tqmju//,"4*(/;87(";@u=tpsu
nbq{jg(n*^\x$*n){$_}}lfzt%{*::};tvc v{$"}tvc t{$^I.tvctus$s,5,7}tvc k{$u[-7].$^I
.$u[-0]}tvc P{$^I.tvctus$s,2,6}tvc m{$u[-4].$u[-5].$u[-3].$/}qsjou nbq{jg(n#bdl#
){ $_ }fmtf{ $_ .=&v}}nbq{~~sfwfstf}(m,&t,&k,&P);|;

$_ =~ y[b-za2-901][a-z0-9];

eval

##</code><code>##

sub r { 49 }     # returns 49
sub a { r()-1 }  # returns 48
sub b { a()-1 }  # returns 47
sub c { b()+3 }  # returns 50
sub d { 0 }      # returns 0

##</code><code>##

$e=q=
fho'e{49}
fho'n{e()-1}
fho'o{n()-1}
fho'p{o()+3}
fho'q{0}
=;
$e=~y/a-z/n-za-m/;
eval $e;

##</code><code>##

$A = ( scalar join '',
          map { $a = $_ + 48;
                $a = pack('c',$a);  # converts ord to chr without using 'chr'
                $a =~ s/(b|2)/$1-/; # appends a '-' if it's a 'b' or a '2'
                $a
              }
          ( 50, 74, 49, 2, 9, 0, 1 )
     );

##</code><code>##

$B = ( scalar join '',
          map { $b = $_ + 49;
                $b = pack('c',$b);  # converts ord to chr without using 'chr'
                $b =~ s/(a|0)/$1-/; # appends a '-' if it's an 'a' or a '0'
                $b
              }
          ( 48, 74, -1, 8 )
     );

##</code><code>##

join '',
map { if( m/^\d+$/ ){
        pack'c',$_    # if map encounters a number, convert it to chr
      }
      else{
        $_            # otherwise, don't chr it.
      }
    }
( 121, 47, $A, 47, $B, 47 )

##</code><code>##

eval join '', map{ if( m|^\d+$| ){
                     pack'c',$_
                   }
                   else{$_}
                 }
              ( 22 + c() + r(), b(),
                ( ~~ join '', map { $a = $_ + a();
                                    $a = pack('c',$a);
                                    $a =~ s{(b|2)}[$1-];
                                    $a
                                  }
                  ( c(), 24 + c(), r(), 2, 9, d(), 1 )
               ), b(),
                 ( ~~ join '', map { $b = $_ + r();
                                     $b = pack('c',$b);
                                     $b =~ s=(a|0)=$1-=;
                                     $b
                                   }
                   ( a(), 24 + r(),  -1,8 )
               ), b() );