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