my $prod = Math::BigInt->new( 1 );
    $prod->bmul( $_ ) for split m{}, $nVal->bstr();

##</code><code>##

    my $prod = Math::BigInt->new( 1 );
    my %digits;
    $digits{ $_ } ++ for split m{}, $nVal->bstr();
    $prod->bmul( $_ ) for
       map {
          $digits{ $_ } > 1
          ? Math::BigInt->new( $_ )->bpow( $digits{ $_ } )
          : $_
          } keys %digits;

##</code><code>##

use 5.018;
use warnings;

use Math::BigInt;
use Time::HiRes qw{ gettimeofday tv_interval };

use Fcntl;
STDOUT->autoflush( 1 );
STDERR->autoflush( 1 );

my $startDigits;
my $stopDigits;

if ( scalar @ARGV == 2 )
{
    ( $startDigits, $stopDigits ) = @ARGV;
}
elsif ( scalar @ARGV == 1 )
{
    $startDigits = 2;
    $stopDigits = shift;
}
else
{
    $startDigits = 2;
    $stopDigits = 8;
}

my $maxSteps  = 0;
my $nTried    = 0;

my $rcGenDigits;
$rcGenDigits = sub
{
    my( $depth, $start ) = @_;
    return [] unless $depth;
    my $raValues;
    foreach my $digit ( $start .. 9 )
    {
        my $raInner = $rcGenDigits->( $depth - 1, $digit );
        push @{ $raValues },
           scalar @{ $raInner }
           ? map { $digit . $_ } @{ $raInner }
           : $digit;
    }
    return $raValues;
};

my $steps;
my $raRecord;

my $startTV = my $lastTV = [ gettimeofday() ];
my $nowTV;
my $elapsed;
my $delta;

foreach my $nDigits ( $startDigits .. $stopDigits )
{
    print
       q{ } x $stopDigits,
       qq{\rGenerating ${nDigits}-digit values ... };
    my $raValues = $rcGenDigits->( $nDigits, 1 );
    $nowTV       = [ gettimeofday() ];
    $delta       = tv_interval( $lastTV, $nowTV );
    $elapsed     = tv_interval( $startTV, $nowTV );
    $lastTV      = $nowTV;
    say
       qq{found @{ [ scalar @{ $raValues } ] }, },
       qq{took @{ [ scaleSecs( $delta ) ] }\n},
       qq{Trying ${nDigits}-digit values, },
       qq{at elapsed time @{ [ scaleSecs( $elapsed ) ] }\n};

    foreach my $value ( @{ $raValues } )
    {
        $nTried ++;
        print STDERR qq{$value\r} unless $nTried %1000;
        $raRecord = [];
        try( $value );
    }

    $nowTV       = [ gettimeofday() ];
    $delta       = tv_interval( $lastTV, $nowTV );
    $lastTV      = $nowTV;
    say
       q{ } x $stopDigits,
       qq{\nTrying ${nDigits}-digit values },
       qq{took @{ [ scaleSecs( $delta ) ] }\n};    
}

say q{ } x $stopDigits, q{};
$nowTV   = [ gettimeofday() ];
$elapsed = tv_interval( $startTV, $nowTV );
say qq{Total elapsed time @{ [ scaleSecs( $elapsed ) ] }\n};

sub per
{
    my $nStr = shift;
    my $nVal = Math::BigInt->new( $nStr );
    push @{ $raRecord }, [ $steps ++, $nVal->bstr() ];
    return if $nVal->bcmp( 10 ) == -1;

    my $prod = Math::BigInt->new( 1 );
    my %digits;
    $digits{ $_ } ++ for split m{}, $nVal->bstr();
    $prod->bmul( $_ ) for
       map {
          $digits{ $_ } > 1
          ? Math::BigInt->new( $_ )->bpow( $digits{ $_ } )
          : $_
          } keys %digits;
    return per( $prod->bstr() );
}

sub scaleSecs
{
    my $tv          = shift;
    my $secs        = int $tv;
    my( $fracPart ) = $tv =~ m{(?<=\.)(\d+)};

    my $wks  = 0;
    my $days = 0;
    my $hrs  = 0;
    my $mins = 0;

    while($secs >= 604800)
    {
        $wks ++;
        $secs -= 604800;
    }
    while($secs >= 86400)
    {
        $days ++;
        $secs -= 86400;
    }
    while($secs >= 3600)
    {
        $hrs ++;
        $secs -= 3600;
    }
    while($secs >= 60)
    {
        $mins ++;
        $secs -= 60;
    }

    my $retStr
       = ( $wks ? qq{${wks}w } : q{} )
       . ( $days ? qq{${days}d } : q{} )
       . ( $hrs ? qq{${hrs}h } : q{} )
       . ( $mins ? qq{${mins}m } : q{} )
       . qq{$secs.${fracPart}s};    
}

sub try
{
    my $nStr = shift;
    $steps   = 0;
    per( $nStr );

    my $actualSteps = $steps - 1;
    if ( $actualSteps > $maxSteps )
    {
        $nowTV    = [ gettimeofday() ];
        $elapsed  = tv_interval( $startTV, $nowTV );
        say
           q{ } x $stopDigits,
           qq{\rFound steps: $actualSteps -- },
           qq{at elapsed time @{ [ scaleSecs( $elapsed ) ] }};
        printf qq{%7d %s\n}, @{ $_ } for @{ $raRecord };
        $maxSteps = $actualSteps;
    }
}

##</code><code>##

Generating 2-digit values ... found 45, took 0.000142s
Trying 2-digit values, at elapsed time 0.000142s

Found steps: 1 -- at elapsed time 0.000444s
      0 11
      1 1
Found steps: 2 -- at elapsed time 0.002256s
      0 25
      1 10
      2 0
Found steps: 3 -- at elapsed time 0.00473s
      0 39
      1 27
      2 14
      3 4
Found steps: 4 -- at elapsed time 0.009294s
      0 77
      1 49
      2 36
      3 18
      4 8
        
Trying 2-digit values took 0.010699s

Generating 3-digit values ... found 165, took 0.000462s
Trying 3-digit values, at elapsed time 0.011303s

Found steps: 5 -- at elapsed time 0.06251s
      0 679
      1 378
      2 168
      3 48
      4 32
      5 6
        
Trying 3-digit values took 0.057506s

Generating 4-digit values ... found 495, took 0.001567s
Trying 4-digit values, at elapsed time 0.070376s

Found steps: 6 -- at elapsed time 0.249183s
      0 6788
      1 2688
      2 768
      3 336
      4 54
      5 20
      6 0
        
Trying 4-digit values took 0.187418s

Generating 5-digit values ... found 1287, took 0.00469s
Trying 5-digit values, at elapsed time 0.262484s

Found steps: 7 -- at elapsed time 0.773186s
      0 68889
      1 27648
      2 2688
      3 768
      4 336
      5 54
      6 20
      7 0
        
Trying 5-digit values took 0.522252s

Generating 6-digit values ... found 3003, took 0.016299s
Trying 6-digit values, at elapsed time 0.801035s

        
Trying 6-digit values took 1.34961s

Generating 7-digit values ... found 6435, took 0.029679s
Trying 7-digit values, at elapsed time 2.180324s

Found steps: 8 -- at elapsed time 4.382705s
      0 2677889
      1 338688
      2 27648
      3 2688
      4 768
      5 336
      6 54
      7 20
      8 0
        
Trying 7-digit values took 3.047357s

Generating 8-digit values ... found 12870, took 0.069061s
Trying 8-digit values, at elapsed time 5.296742s

Found steps: 9 -- at elapsed time 10.071529s
      0 26888999
      1 4478976
      2 338688
      3 27648
      4 2688
      5 768
      6 336
      7 54
      8 20
      9 0
        
Trying 8-digit values took 6.295458s

        
Total elapsed time 11.593337s


##</code><code>##

Generating 26-digit values ... found 18156204, took 4m 56.352544s
Trying 26-digit values, at elapsed time 4m 56.352544s

Found steps: 1 -- at elapsed time 4m 56.352979s
      0 11111111111111111111111111
      1 1
Found steps: 2 -- at elapsed time 4m 56.35532s
      0 11111111111111111111111125
      1 10
      2 0
Found steps: 3 -- at elapsed time 4m 56.35849s
      0 11111111111111111111111139
      1 27
      2 14
      3 4
Found steps: 4 -- at elapsed time 4m 56.364262s
      0 11111111111111111111111177
      1 49
      2 36
      3 18
      4 8
Found steps: 5 -- at elapsed time 4m 56.408053s
      0 11111111111111111111111679
      1 378
      2 168
      3 48
      4 32
      5 6
Found steps: 6 -- at elapsed time 4m 56.552653s
      0 11111111111111111111116788
      1 2688
      2 768
      3 336
      4 54
      5 20
      6 0
Found steps: 7 -- at elapsed time 4m 56.92614s
      0 11111111111111111111168889
      1 27648
      2 2688
      3 768
      4 336
      5 54
      6 20
      7 0
Found steps: 8 -- at elapsed time 4m 58.708825s
      0 11111111111111111112677889
      1 338688
      2 27648
      3 2688
      4 768
      5 336
      6 54
      7 20
      8 0
Found steps: 9 -- at elapsed time 5m 1.542849s
      0 11111111111111111126888999
      1 4478976
      2 338688
      3 27648
      4 2688
      5 768
      6 336
      7 54
      8 20
      9 0
Found steps: 10 -- at elapsed time 5m 19.523648s
      0 11111111111111113778888999
      1 438939648
      2 4478976
      3 338688
      4 27648
      5 2688
      6 768
      7 336
      8 54
      9 20
     10 0
Found steps: 11 -- at elapsed time 9m 34.047507s
      0 11111111111277777788888899
      1 4996238671872
      2 438939648
      3 4478976
      4 338688
      5 27648
      6 2688
      7 768
      8 336
      9 54
     10 20
     11 0
                           
Trying 26-digit values took 3h 46m 34.174622s

Generating 27-digit values ... found 23535820, took 6m 47.473396s
Trying 27-digit values, at elapsed time 3h 58m 18.000562s

                           
Trying 27-digit values took 4h 57m 27.198992s

                           
Total elapsed time 8h 55m 47.367434s