sub Encrypt($$$) {
        require Math::BigInt; # vorher: do 'bigint.pl';

        my( $u, $n, $m ) = @_;

        # vorher: $u =~ s/^.(..)*$/0$&/;
        # verständlicher:
        $u = '0'. $u;
        $u = '0' if length($u) % 2 != 0; # ungerade anzahl an zeichen?

        # in $u befinden sich hexadezimale daten
        # diese werden zunächst in eine dezimalzahl umgewandelt(aus A wird 10)
        # dann wird die dezimalzahl in einen bitstring(einsen und nullen) umgewandelt
        # die daten liegen jetzt im little-endian format als bitstring vor
        # und landen in $k
        my $k = unpack( 'B*', pack( 'H*', $u ) );
        $k =~ s/^0*//; # führende nullen entfernen

        # vorher: my $x = 0;
        #         my $z = $n =~ s/./$x=&::badd(&::bmul($x, 16), hex$&)/ge;
        # verständlicher:
        my $x = Math::BigInt->bzero;
        my $z = length($n);

        for my $i ( 0 .. $z-1 ) {
                my $chr = substr( $n, $i, 1 );
                next if $chr eq "\n"; # wahrscheinlich überflüssig

                $x->badd( $x->bmul(16), hex $chr );
                substr( $n, $i, 1, $x->bstr );
        } # for

        # ($z-1) & ~1 macht aus einer ungerade zahl die nächst kleinere gerade zahl
        # eine gerade zahl, bleibt dabei gerade
        # diese nun gerade zahl, wird durch 2 geteilt, das ergebnis landet in $w
        my $w = ( ($z-1) & ~1 ) / 2;

        # damit in $u auf jeden fall "$w" zeichen landen, werden an $m "$w" nullbytes angehängt
        # dann werden von beginn dieser zeichenkette die ersten "$w" zeichen genommen und in $u gepackt
        $u = substr( $m . "\0" x $w, 0, $w );

        # vorher: $c = 0;
        #         $u =~ s/.|\n/$c=&::badd(&::bmul($c, 256), ord$&)/ge;
        # verständlicher:
        my $c = Math::BigInt->bzero;

        for my $i ( 0 .. length($u)-1 ) {
                my $chr = substr( $u, $i, 1 );
                $c->badd( $c->bmul(256), ord $chr );
                substr( $u, $i, 1, $c->bstr );
        } # for

        my $r = Math::BigInt->bone;
        my $t;
        $u = $k; # $u wird wieder auf den anfangs erzeugten bitstring gesetzt

        # vorher: $u =~ s/./$r=&::bmod(&::bmul($r, $r), $x), $&?$r=&::bmod(&::bmul($r, $c), $x):0,""/ge;
        # verständlicher:
        for my $i ( 0 .. length($u)-1 ) {
                my $chr = substr( $u, $i, 1 );

                $r->bmod( $r->bmul($r), $x );

                if ( $chr == 1 ) {
                        $r->bmod( $r->bmul($c), $x );
                        substr( $u, $i, 1, $r->bstr );
                } # if
                else {
                        substr( $u, $i, 1, '' );
                } # else
        } # for

        # was hier noch passiert, kann ich dir leider auch nicht sagen:
        while ( $w-- + 1 ) {
                ( $r, $t ) = $r->bdiv(256);
                $u = pack( 'C', $t->bstr ) . $u;
        } # while

        return unpack( 'H*', $u );
} # Encrypt