cleanups

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@6531 8c9fc860-2736-0410-a75d-ab315db34111

source/CryptoBigNumbers.Mod

@@ -6,7 +6,6 @@ MODULE CryptoBigNumbers;  (* g.f.	2001.10.07 *)
 (* 2005.07.07	g.f.	Fabian Nart's enhancements incorporated *)
 (* 2010.01.12	g.f.	interface cleanup, most procedures got funtions *)
 
-(**  Computing big numbers up to 1024 hex digits. *)
 
 IMPORT S := SYSTEM, Streams, Random, Kernel, Out := KernelLog;
 
@@ -18,7 +17,7 @@ TYPE
 
 	BigNumber* = OBJECT
 			VAR
-				len-: INTEGER;  (** number of significant 'digits' *)
+				len-: LONGINT;  (** number of significant 'digits' *)
 				neg-: BOOLEAN;
 				d-: digits;
 
@@ -32,6 +31,148 @@ TYPE
 					END;
 					len := 0;  neg := FALSE
 				END Init;
+				
+				PROCEDURE Mask*( bits: LONGINT );
+				VAR w, b: LONGINT;
+				BEGIN
+					w := bits DIV 32;  b := bits MOD 32;  len := w;
+					IF b # 0 THEN  INC( len );
+						d[w] := S.VAL( LONGINT,  S.VAL( SET, d[w] ) * {0..b} )
+					END
+				END Mask;
+
+				
+				PROCEDURE IsZero*( ): BOOLEAN;
+				BEGIN
+					RETURN (len = 0) OR ((len = 1) & (d[0] = 0))
+				END IsZero;
+				
+				PROCEDURE EQ* ( b: BigNumber ): BOOLEAN;
+				BEGIN
+					RETURN Cmp( SELF, b ) = 0
+				END EQ;
+				
+				PROCEDURE NEQ* ( b: BigNumber ): BOOLEAN;
+				BEGIN
+					RETURN Cmp( SELF, b ) # 0
+				END NEQ;
+				
+				PROCEDURE GT* ( b: BigNumber ): BOOLEAN;
+				BEGIN
+					RETURN Cmp( SELF, b ) > 0
+				END GT;
+				
+				PROCEDURE GEQ* ( b: BigNumber ): BOOLEAN;
+				BEGIN
+					RETURN Cmp( SELF, b ) >= 0
+				END GEQ;
+
+
+
+				PROCEDURE Shift*( n: LONGINT );
+				VAR right: BOOLEAN;  w, bits, i, l: LONGINT;  a, b: LONGINT;
+				BEGIN
+					IF len = 0 THEN  RETURN  END;
+					IF n < 0 THEN  right := TRUE;  n := ABS( n )  ELSE  right := FALSE  END;
+					w := n DIV 32;  bits := n MOD 32;
+					IF ~right THEN  
+						adjust( len + w + 1 );
+						IF w > 0 THEN
+							FOR i := len - 1 TO 0 BY -1 DO  d[i + w] := d[i]  END;
+							FOR i := 0 TO w - 1 DO  d[i] := 0  END;
+							INC( len, w )
+						END;
+						IF bits > 0 THEN  
+							d[len] := 0;
+							FOR i := len TO 0 BY -1 DO  
+								a := d[i];
+								IF i > 0 THEN  b := d[i - 1]  ELSE  b := 0  END;
+								d[i] := LSH( a, bits ) + LSH( b, -32 + bits )
+							END;
+							IF d[len] # 0 THEN  INC( len )  END;
+						END
+					ELSE
+						IF w > 0 THEN
+							FOR i := 0 TO len - w - 1 DO  d[i] := d[i + w]  END;
+							DEC( len, w )
+						END;
+						IF bits > 0 THEN  
+							l := len;
+							FOR i := 0 TO  l - 1 DO  a := d[i];
+								IF i < l - 1 THEN  b := d[i + 1]  ELSE  b := 0  END;
+								d[i] := LSH( a, -bits ) + LSH( b, 32 - bits )
+							END;
+							IF d[l - 1] = 0 THEN  DEC( len )  END;
+						END
+					END;
+				END Shift;
+				
+
+				PROCEDURE Dec*;
+				VAR i: LONGINT;
+				BEGIN
+					i := 0;
+					IF IsZero( ) THEN  len := 1;  neg := TRUE;  d[0] := 1
+					ELSIF neg THEN
+						WHILE (d[i] = -1) & (i < len) DO  d[i] := 0;  INC( i )  END;
+						IF i = len THEN  d[i] := 1;  INC( len )  ELSE  INC( d[i] )  END
+					ELSE
+						WHILE d[i] = 0 DO  d[i] := -1;  INC( i )  END;
+						DEC( d[i] );  fixlen( d, len )
+					END
+				END Dec;
+
+				PROCEDURE Inc*;
+				VAR i: LONGINT;
+				BEGIN
+					i := 0;
+					IF ~neg THEN
+						WHILE (d[i] = -1) & (i < len) DO  d[i] := 0;  INC( i )  END;
+						IF i = len THEN  d[i] := 1;  INC( len )  ELSE  INC( d[i] )  END
+					ELSE
+						WHILE d[i] = 0 DO  d[i] := -1;  INC( i )  END;
+						DEC( d[i] );  fixlen( d, len );
+						IF len = 0 THEN  neg := FALSE  END
+					END
+				END Inc;
+
+				PROCEDURE Negate*;
+				BEGIN
+					IF ~IsZero( ) THEN  neg := ~neg  END
+				END Negate;
+	
+				PROCEDURE BitSize*( ): LONGINT;
+				VAR n, t: LONGINT;
+				BEGIN
+					IF len = 0 THEN  RETURN 0
+					ELSE  n := (len - 1) * 32
+					END;
+					t := d[len - 1];
+					WHILE t # 0 DO  INC( n );  t := LSH( t, -1 )  END;
+					RETURN n 
+				END BitSize;
+
+				PROCEDURE BitSet*( n: LONGINT ): BOOLEAN;
+				VAR w, bit: LONGINT;
+				BEGIN
+					w := n DIV 32;  bit := n MOD 32;
+					IF w >= len THEN  RETURN FALSE
+					ELSE  RETURN  bit IN S.VAL( SET, d[w] )
+					END
+				END BitSet;
+
+
+				PROCEDURE adjust( newlen: LONGINT );
+				VAR n, i: LONGINT;  nd: digits;
+				BEGIN
+					n := 16;
+					WHILE n < newlen DO  INC( n, 16 )  END;
+					IF LEN( d ) < n THEN
+						NEW( nd, n );
+						FOR i := 0 TO LEN( d^ ) - 1 DO  nd[i] := d[i]  END;
+						d := nd
+					END;
+				END adjust;
 
 			END BigNumber;
 
@@ -40,34 +181,33 @@ TYPE
 
 	Montgomery = OBJECT
 				VAR
-					bits: INTEGER;	(* of R *)
+					bits: LONGINT;	(* of R *)
 					r, n, t1, t2: BigNumber;
 
 				PROCEDURE & Init( x: BigNumber );
 				BEGIN
 					Copy( x, n );  bits := x.len*32;
-					AssignInt( r, 1 );  Shift( r, bits );	(* r := R *)
+					AssignInt( r, 1 );  r.Shift( bits );	(* r := R *)
 					r := Sub( r, ModInverse( n, r ) );   (* r := R - (1/n)  (mod R) *)
-					adjust( n.d, n.len, 2*x.len );
-					adjust( r.d, r.len, 2*x.len );
-					NEW( t1, 2*bits );
-					NEW( t2, 2*bits );
+					n.adjust( 2*x.len );  r.adjust( 2*x.len );
+					NEW( t1, 2*bits );  NEW( t2, 2*bits );
 				END Init;
 
 				PROCEDURE Convert( VAR val: BigNumber ); 	(* val := val ^ R mod n *)
 				VAR i: LONGINT;
 				BEGIN
-					FOR i := 0 TO bits - 1 DO  Shift( val, 1 );
+					FOR i := 0 TO bits - 1 DO  
+						val.Shift( 1 );
 						IF ucmp( val, n ) >= 0 THEN  val := Sub( val, n )  END
 					END
 				END Convert;
 
 				PROCEDURE Reduce( VAR val: BigNumber ); 	(* val := val ^ (1/R) mod n *)
 				BEGIN
-					Copy( val, t1 );  Mask( t1, bits - 1 ); 	(* val mod R *)
-					mul( t1.d, r.d, t2.d, t1.len, r.len, t2.len );  Mask( t2, bits - 1 ); 	(* mod R *)
+					Copy( val, t1 );  t1.Mask( bits - 1 ); 	(* val mod R *)
+					mul( t1.d, r.d, t2.d, t1.len, r.len, t2.len );  t2.Mask( bits - 1 ); 	(* mod R *)
 					mul( t2.d, n.d, t1.d, t2.len, n.len, t1.len );
-					add( t1.d, val.d, val.d, t1.len, val.len, val.len );  Shift( val, -bits ); 	(* div R *)
+					add( t1.d, val.d, val.d, t1.len, val.len, val.len );  val.Shift( -bits ); 	(* div R *)
 					IF ucmp( val, n ) >= 0 THEN  sub( val.d, n.d, val.d, val.len, n.len, val.len )  END;
 				END Reduce;
 
@@ -91,7 +231,7 @@ VAR
 	randomgenerator: Random.Generator;
 
 
-	PROCEDURE max( a, b: INTEGER ): INTEGER;
+	PROCEDURE max( a, b: LONGINT ): LONGINT;
 	BEGIN
 		IF a >= b THEN  RETURN a  ELSE  RETURN b  END;
 	END max;
@@ -113,16 +253,16 @@ VAR
 		END
 	END LessOrEqual;
 
-	PROCEDURE RandomBytes*( VAR buf: ARRAY OF CHAR;  p: LONGINT;  n: INTEGER );
-	VAR i: INTEGER;
+	PROCEDURE RandomBytes*( VAR buf: ARRAY OF CHAR;  p: LONGINT;  n: LONGINT );
+	VAR i: LONGINT;
 	BEGIN
 		FOR i := 0 TO n - 1 DO buf[p + i] := CHR( ENTIER( randomgenerator.Uniform()*256 ) ) END
 	END RandomBytes;
 
 
 
-	PROCEDURE adjust( VAR d: digits;  dl, len: INTEGER );
-	VAR n, i: INTEGER;  nd: digits;
+	PROCEDURE adjust( VAR d: digits;  dl, len: LONGINT );
+	VAR n, i: LONGINT;  nd: digits;
 	BEGIN
 		ASSERT( d # NIL );
 		n := 16;
@@ -136,8 +276,8 @@ VAR
 
 
 	(** random number with len 'bits' *)
-	PROCEDURE NewRand*( bits: INTEGER;  top, bottom: SHORTINT ): BigNumber;
-	VAR n, len, i, topbit: INTEGER;  topword: SET;  b: BigNumber;
+	PROCEDURE NewRand*( bits: LONGINT;  top, bottom: SHORTINT ): BigNumber;
+	VAR n, len, i, topbit: LONGINT;  topword: SET;  b: BigNumber;
 	BEGIN
 		len := bits;  INC( len, (-len) MOD 32 );
 		NEW( b, len );
@@ -157,12 +297,12 @@ VAR
 	PROCEDURE NewRandRange*( range: BigNumber ): BigNumber;	(** 0 < b < range DIV 2 - 1*)
 	VAR  b: BigNumber;
 	BEGIN
-		b := NewRand( BitSize( range ) - 1, 0, 0 );
-		Dec( b );
+		b := NewRand( range.BitSize( ) - 1, 0, 0 );
+		b.Dec;
 		RETURN b
 	END NewRandRange;
 
-	PROCEDURE fixlen( VAR d: digits;  VAR len: INTEGER );
+	PROCEDURE fixlen( VAR d: digits;  VAR len: LONGINT );
 	BEGIN
 		WHILE (len > 0) & (d[len - 1] = 0) DO  DEC( len )  END;
 	END fixlen;
@@ -172,14 +312,14 @@ VAR
 	BEGIN
 		CASE c OF
 		| '0'..'9':  v := ORD( c ) - ORD( '0' )
-		| 'a'..'f':   v := ORD( c ) - ORD( 'a' ) + 10
+		| 'a'..'f':  v := ORD( c ) - ORD( 'a' ) + 10
 		| 'A'..'F':  v := ORD( c ) - ORD( 'A' ) + 10
 		ELSE  HALT( 99 )
 		END;
 		RETURN v
 	END h2i;
 
-	PROCEDURE AssignHex*( VAR b: BigNumber;  CONST hex: ARRAY OF CHAR;  len: INTEGER );
+	PROCEDURE AssignHex*( VAR b: BigNumber;  CONST hex: ARRAY OF CHAR;  len: LONGINT );
 	VAR n, w, pos: LONGINT;
 	BEGIN
 		ASSERT( len <= LEN( hex ) - 1);
@@ -228,8 +368,8 @@ VAR
 		IF val # 0 THEN  b.len := 1;  b.d[0] := val  ELSE  b.len := 0   END
 	END AssignInt;
 
-	PROCEDURE cmpd( VAR a, b: digits;  len: INTEGER ): SHORTINT;
-	VAR i: INTEGER;
+	PROCEDURE cmpd( VAR a, b: digits;  len: LONGINT ): SHORTINT;
+	VAR i: LONGINT;
 	BEGIN
 		i := len - 1;
 		WHILE (i >= 0) & (a[i] = b[i]) DO  DEC( i )  END;
@@ -256,8 +396,8 @@ VAR
 		END
 	END Cmp;
 
-	PROCEDURE copy( a, b: digits;  len: INTEGER );
-	VAR i: INTEGER;
+	PROCEDURE copy( a, b: digits;  len: LONGINT );
+	VAR i: LONGINT;
 	BEGIN
 		FOR i := 0 TO len - 1 DO  b[i] := a[i]  END
 	END copy;
@@ -274,8 +414,8 @@ VAR
 		RETURN S.VAL( LONGINT, -S.VAL( SET, x ) )
 	END Invert;
 
-	PROCEDURE add( a, b: digits; VAR c: digits;  al, bl: INTEGER;  VAR cl: INTEGER );
-	VAR i, n: INTEGER;  A, B, x: LONGINT;  carry: BOOLEAN;
+	PROCEDURE add( a, b: digits; VAR c: digits;  al, bl: LONGINT;  VAR cl: LONGINT );
+	VAR i, n: LONGINT;  A, B, x: LONGINT;  carry: BOOLEAN;
 	BEGIN
 		n := max( al, bl );  carry := FALSE;
 		IF LEN( c^ ) < (n + 1) THEN  adjust( c, cl, n + 1 )  END;
@@ -283,15 +423,17 @@ VAR
 			IF i >= al THEN  A := 0  ELSE  A := a[i]  END;
 			IF i >= bl THEN  B := 0  ELSE  B := b[i]  END;
 			x := A + B;
-			IF carry THEN  INC( x );  carry := LessOrEqual( Invert( A ), B )  ELSE  carry := LessThan( x, B )  END;
+			IF carry THEN  INC( x );  carry := LessOrEqual( Invert( A ), B )  
+			ELSE  carry := LessThan( x, B )  
+			END;
 			c[i]:= x
 		END;
 		IF carry  THEN  c[n] := 1;  INC( n )  END;
 		cl := n
 	END add;
 
-	PROCEDURE sub( a, b: digits;  VAR c: digits;  al, bl: INTEGER;  VAR cl: INTEGER );
-	VAR i, n: INTEGER;  A, B, x: LONGINT;  borrow: BOOLEAN;
+	PROCEDURE sub( a, b: digits;  VAR c: digits;  al, bl: LONGINT;  VAR cl: LONGINT );
+	VAR i, n: LONGINT;  A, B, x: LONGINT;  borrow: BOOLEAN;
 	BEGIN
 		n := max( al, bl );  borrow := FALSE;
 		IF LEN( c^ ) < n THEN  adjust( c, cl, n )  END;
@@ -308,7 +450,7 @@ VAR
 	END sub;
 
 	PROCEDURE Add*( a, b: BigNumber ): BigNumber;   (**  a + b *)
-	VAR sd: digits;  l, sl: INTEGER;  c: BigNumber;
+	VAR sd: digits;  l, sl: LONGINT;  c: BigNumber;
 	BEGIN
 		ASSERT( (a # NIL) & (b # NIL) );
 		l := max( a.len, b.len ) + 1;
@@ -321,12 +463,12 @@ VAR
 		END;
 		IF sd # c.d THEN  adjust( c.d, 0, sl );  copy( sd, c.d, sl )  END;
 		c.len := sl;
-		IF Zero( c ) THEN  c.neg := FALSE  END;
+		IF c.IsZero( ) THEN  c.neg := FALSE  END;
 		RETURN c
 	END Add;
 
 	PROCEDURE Sub*( a, b: BigNumber ): BigNumber;   (**  a - b  *)
-	VAR sd: digits;  l, sl: INTEGER;  c: BigNumber;
+	VAR sd: digits;  l, sl: LONGINT;  c: BigNumber;
 	BEGIN
 		ASSERT( (a # NIL) & (b # NIL) );
 		l := max( a.len, b.len ) + 1;
@@ -339,7 +481,7 @@ VAR
 			END;
 		IF sd # c.d THEN  adjust( c.d, 0, sl );  copy( sd, c.d, sl )  END;
 		c.len := sl;
-		IF Zero( c ) THEN  c.neg := FALSE  END;
+		IF c.IsZero( ) THEN  c.neg := FALSE  END;
 		RETURN c
 	END Sub;
 
@@ -362,25 +504,10 @@ VAR
 	END MulAdd;
 
 
-	(* didn't work + depends on endianess !
-	PROCEDURE MulAdd( VAR high, low: LONGINT;  b, c, d: LONGINT );  	(* high | low := b * c + d *)
-	TYPE HI = RECORD lo, hi: LONGINT  END;
-	VAR res: HUGEINT;
-		tb, tc: HI;
-	BEGIN
-		tb.lo := b;  tb.hi := 0;
-		tc.lo := c;  tc.hi := 0;
-		res := S.VAL( HUGEINT, tb ) * S.VAL( HUGEINT, tc );
-		INC( res, d );
-		low := SHORT( res );
-		high := SHORT( LSH( res, -32 ) );
-	END MulAdd;
-	*)
-
 
-	PROCEDURE mul( a, b: digits; VAR c: digits;  al, bl: INTEGER;  VAR cl: INTEGER );  (* c := a*b *)
+	PROCEDURE mul( a, b: digits; VAR c: digits;  al, bl: LONGINT;  VAR cl: LONGINT );  (* c := a*b *)
 	VAR
-		prod, sum, tmp, mulc: LONGINT;  addc: BOOLEAN;  i, j: INTEGER;  pl: INTEGER;
+		prod, sum, tmp, mulc: LONGINT;  addc: BOOLEAN;  i, j: LONGINT;  pl: LONGINT;
 		p: digits;
 	BEGIN
 		pl := 0;  NEW( p, al + bl + 2 );
@@ -404,8 +531,8 @@ VAR
 		c := p;  cl := pl;  fixlen( c, cl );
 	END mul;
 
-	PROCEDURE muls( a: digits;  b: LONGINT; c: digits;  al: INTEGER;  VAR cl: INTEGER );  (* c := a * b *)
-	VAR carry: LONGINT;  i: INTEGER;
+	PROCEDURE muls( a: digits;  b: LONGINT; c: digits;  al: LONGINT;  VAR cl: LONGINT );  (* c := a * b *)
+	VAR carry: LONGINT;  i: LONGINT;
 	BEGIN
 		carry := 0;  cl := al;
 		FOR i := 0 TO al - 1 DO
@@ -415,7 +542,7 @@ VAR
 	END muls;
 
 	PROCEDURE Mul*( a, b: BigNumber ): BigNumber;   (**  a * b  *)
-	VAR pd: digits;  pl: INTEGER;  c: BigNumber;
+	VAR pd: digits;  pl: LONGINT;  c: BigNumber;
 	BEGIN
 		ASSERT( (a # NIL) & (b # NIL) );
 		IF (a.len = 0) OR (b.len = 0) THEN  AssignInt( c, 0 );  RETURN c  END;
@@ -430,7 +557,7 @@ VAR
 	END Mul;
 
 	PROCEDURE div64( CONST a: dig2;  VAR b: LONGINT ): LONGINT;   (* a div b *)
-	VAR bit: INTEGER;  q, r: LONGINT;  overflow: BOOLEAN;
+	VAR bit: LONGINT;  q, r: LONGINT;  overflow: BOOLEAN;
 	BEGIN
 		IF a[1] = 0 THEN
 			IF (a[0] >= 0) & (b >= 0 ) THEN  RETURN a[0] DIV b
@@ -455,7 +582,7 @@ VAR
 	END div64;
 
 	PROCEDURE div96( CONST a: dig3;  CONST b: dig2 ): LONGINT;   (* a div b *)
-	VAR bit: INTEGER;  r: dig2;  q: LONGINT;  overflow, borrow: BOOLEAN;
+	VAR bit: LONGINT;  r: dig2;  q: LONGINT;  overflow, borrow: BOOLEAN;
 
 		PROCEDURE ge( CONST a, b: dig2 ): BOOLEAN;
 		BEGIN
@@ -493,12 +620,12 @@ VAR
 	END div96;
 
 	PROCEDURE Div2*( a, b: BigNumber;  VAR q, r: BigNumber );   (** q := a div b;  r := a mod b *)
-	VAR x: LONGINT;  td, sd, bd, qd: digits;  i, tail, bl, tl, sl, ql, qi: INTEGER;
+	VAR x: LONGINT;  td, sd, bd, qd: digits;  i, tail, bl, tl, sl, ql, qi: LONGINT;
 		t3: dig3;  t2, d0: dig2;
 		aq, ar: ADDRESS;
 	BEGIN
 		aq := ADDRESSOF( q );   ar := ADDRESSOF( r );
-		ASSERT( (a # NIL) & (b # NIL) & ~Zero( b ) & ~b.neg & (aq # ar) );
+		ASSERT( (a # NIL) & (b # NIL) & ~b.IsZero( ) & ~b.neg & (aq # ar) );
 		NEW( q, a.len*32 );  qd := q.d;
 
 		x := ucmp( a, b );
@@ -512,30 +639,30 @@ VAR
 			FOR i := 1 TO bl DO  td[bl - i] := a.d[a.len - i]  END;
 			tl := bl;  tail := a.len - bl;  ql := tail + 1;  qi := ql;
 			LOOP
-					IF tl < bl THEN  x := 0;
-					ELSE i := tl  - 1;
-						IF d0[0] = 0 THEN
-							IF tl > bl THEN  t2[1] := td[i];  DEC( i )  ELSE  t2[1] := 0  END;
-							t2[0] := td[i];
-							x := div64( t2, d0[1] );
-						ELSE
-							IF tl > bl THEN  t3[2] := td[i];  DEC( i )  ELSE  t3[2] := 0  END;
-							t3[1] := td[i];
-							IF i > 0 THEN  t3[0] := td[i - 1]  ELSE  t3[0] := 0   END;
-							x := div96( t3, d0 );
-						END
-					END;
-					IF x # 0 THEN  muls( bd, x, sd, bl, sl );
-						WHILE (sl > tl) OR ((sl = tl) & (cmpd( sd, td, sl ) > 0)) DO
-							sub( sd, bd, sd, sl, bl, sl );  DEC( x );
-						END;
-						sub( td, sd, td, tl, sl, tl );
+				IF tl < bl THEN  x := 0;
+				ELSE i := tl  - 1;
+					IF d0[0] = 0 THEN
+						IF tl > bl THEN  t2[1] := td[i];  DEC( i )  ELSE  t2[1] := 0  END;
+						t2[0] := td[i];
+						x := div64( t2, d0[1] );
+					ELSE
+						IF tl > bl THEN  t3[2] := td[i];  DEC( i )  ELSE  t3[2] := 0  END;
+						t3[1] := td[i];
+						IF i > 0 THEN  t3[0] := td[i - 1]  ELSE  t3[0] := 0   END;
+						x := div96( t3, d0 );
+					END
+				END;
+				IF x # 0 THEN  muls( bd, x, sd, bl, sl );
+					WHILE (sl > tl) OR ((sl = tl) & (cmpd( sd, td, sl ) > 0)) DO
+						sub( sd, bd, sd, sl, bl, sl );  DEC( x );
 					END;
-					IF (qi = ql) & (x = 0) THEN  DEC( ql );  DEC( qi )  ELSE  DEC( qi );  qd[qi] := x  END;
-					IF tail = 0 THEN  EXIT  END;
-					DEC( tail );
-					FOR i := tl TO 1 BY -1 DO  td[i] := td[i - 1]  END;
-					td[0] := a.d[tail];  INC( tl );
+					sub( td, sd, td, tl, sl, tl );
+				END;
+				IF (qi = ql) & (x = 0) THEN  DEC( ql );  DEC( qi )  ELSE  DEC( qi );  qd[qi] := x  END;
+				IF tail = 0 THEN  EXIT  END;
+				DEC( tail );
+				FOR i := tl TO 1 BY -1 DO  td[i] := td[i - 1]  END;
+				td[0] := a.d[tail];  INC( tl );
 			END;
 			q.len := ql;
 			NEW( r, tl*32 );  copy( td, r.d, tl );  r.len := tl;
@@ -543,11 +670,11 @@ VAR
 			RecycleBuffer( sd )
 		END;
 		IF q.len = 0 THEN  q.neg := FALSE  ELSE  q.neg := a.neg  END;
-		IF (r.len # 0) & a.neg THEN  Dec( q );  r := Sub( b, r )  END;
+		IF (r.len # 0) & a.neg THEN  q.Dec;  r := Sub( b, r )  END;
 	END Div2;
 
 	PROCEDURE ModWord*( VAR a: BigNumber;  b: LONGINT ): LONGINT;   (**  a mod b *)
-	VAR x: LONGINT;  td, sd, bd: digits;  tail, tl, sl, bl: INTEGER;  t2: dig2;
+	VAR x: LONGINT;  td, sd, bd: digits;  tail, tl, sl, bl: LONGINT;  t2: dig2;
 	BEGIN
 		ASSERT( a # NIL );
 		td := GetBuffer();
@@ -555,19 +682,19 @@ VAR
 		bd := GetBuffer();
 		bd[0] := b;  bl := 1;  td[0] := a.d[a.len - 1];  tl := 1;  tail := a.len - 1;
 		LOOP
-				IF tl > 1 THEN  t2[1] := td[1]  ELSE  t2[1] := 0  END;
-				t2[0] := td[0];
-				x := div64( t2, b );
-				IF x # 0 THEN  muls( bd, x, sd, bl, sl );
-					WHILE (sl > tl) OR ((sl = tl) & (cmpd( sd, td, sl ) > 0)) DO
-						sub( sd, bd, sd, sl, bl, sl );  DEC( x );
-					END;
-					sub( td, sd, td, tl, sl, tl );
+			IF tl > 1 THEN  t2[1] := td[1]  ELSE  t2[1] := 0  END;
+			t2[0] := td[0];
+			x := div64( t2, b );
+			IF x # 0 THEN  muls( bd, x, sd, bl, sl );
+				WHILE (sl > tl) OR ((sl = tl) & (cmpd( sd, td, sl ) > 0)) DO
+					sub( sd, bd, sd, sl, bl, sl );  DEC( x );
 				END;
-				IF tail <= 0 THEN  EXIT  END;
-				DEC( tail );
-				IF td[0] = 0 THEN  tl := 1  ELSE td[1] := td[0];  tl := 2  END;
-				td[0] := a.d[tail];
+				sub( td, sd, td, tl, sl, tl );
+			END;
+			IF tail <= 0 THEN  EXIT  END;
+			DEC( tail );
+			IF td[0] = 0 THEN  tl := 1  ELSE td[1] := td[0];  tl := 2  END;
+			td[0] := a.d[tail];
 		END;
 		x := td[0];
 		RecycleBuffer( td );
@@ -590,36 +717,17 @@ VAR
 		RETURN r
 	END Mod;
 
-	PROCEDURE BitSize*( VAR b: BigNumber ): INTEGER;
-	VAR n, t: LONGINT;
-	BEGIN
-		IF b.len = 0 THEN  RETURN 0
-		ELSE  n := (b.len - 1) * 32
-		END;
-		t := b.d[b.len - 1];
-		WHILE t # 0 DO  INC( n );  t := LSH( t, -1 )  END;
-		RETURN SHORT( n )
-	END BitSize;
-
-	PROCEDURE BitSet*( VAR b: BigNumber; n: LONGINT ): BOOLEAN;
-	VAR w, bit: LONGINT;
-	BEGIN
-		w := n DIV 32;  bit := n MOD 32;
-		IF w >= b.len THEN  RETURN FALSE
-		ELSE  RETURN  bit IN S.VAL( SET, b.d[w] )
-		END
-	END BitSet;
 
 	PROCEDURE Exp*( a, b: BigNumber ): BigNumber;   (**  a ^ b  *)
-	VAR v: digits; i: LONGINT; vl: INTEGER;  e: BigNumber;
+	VAR v: digits; i: LONGINT; vl: LONGINT;  e: BigNumber;
 	BEGIN
 		NEW( e, 8192 );
 		NEW( v, 256 );
 		copy( a.d, v, a.len );  vl := a.len;
 		IF ODD( b.d[0] ) THEN  copy( a.d, e.d, a.len );  e.len := a.len  ELSE  e.len := 1; e.d[0] := 1  END;
-		FOR i := 1 TO BitSize( b ) - 1 DO
+		FOR i := 1 TO b.BitSize( ) - 1 DO
 			mul( v, v, v, vl, vl, vl );
-			IF BitSet( b, i ) THEN   mul( v, e.d, e.d, vl, e.len, e.len )  END;
+			IF b.BitSet( i ) THEN   mul( v, e.d, e.d, vl, e.len, e.len )  END;
 		END;
 		fixlen( e.d, e.len );
 		RETURN e
@@ -632,11 +740,11 @@ VAR
 		RETURN r
 	END ModMul;
 
-	PROCEDURE wbits( exp: BigNumber ): INTEGER;
-	VAR b, w: INTEGER;
+	PROCEDURE wbits( exp: BigNumber ): LONGINT;
+	VAR b, w: LONGINT;
 	BEGIN
 		(* window bits for exponent size,  for sliding window ModExp functions *)
-		b := BitSize( exp );
+		b := exp.BitSize( );
 		IF b <= 23 THEN  w := 1
 		ELSIF b <= 79 THEN  w := 3
 		ELSIF b <= 239 THEN  w := 4
@@ -652,12 +760,12 @@ VAR
 		wsize, v, wstart, e, i, j: LONGINT;
 		mg: Montgomery;
 	BEGIN
-		ASSERT( ( a # NIL) & ( b # NIL) & ( m # NIL) );
-		IF Zero( b ) THEN
-			IF Zero( a ) THEN HALT( 100 ) END;
+		ASSERT( (a # NIL) & (b # NIL) & (m # NIL) );
+		IF b.IsZero( ) THEN
+			IF a.IsZero( ) THEN HALT( 100 ) END;
 			AssignInt( res, 1 );  RETURN  res
 		END;
-		IF Zero( m ) THEN  HALT( 101 )  END;
+		IF m.IsZero( ) THEN  HALT( 101 )  END;
 		IF m.neg THEN  HALT( 102 )  END;
 
 		NEW( mg, m );
@@ -669,12 +777,12 @@ VAR
 			FOR i := 1 TO j - 1 DO  a0[i] := mg.Mult( a0[i - 1], d )  END;
 		END;
 
-		Copy( a0[0], res );  wstart := BitSize( b ) - 2;
+		Copy( a0[0], res );  wstart := b.BitSize( ) - 2;
 		WHILE wstart >= 0 DO  res := mg.Mult( res, res );
-			IF BitSet( b, wstart ) THEN
+			IF b.BitSet( wstart ) THEN
 				v := 1;  e := 0;  i := 1;
 				WHILE (i < wsize) & (wstart - i >= 0) DO
-					IF BitSet( b, wstart - i ) THEN  v := ASH( v, i - e ) + 1;  e := i  END;
+					IF b.BitSet( wstart - i ) THEN  v := ASH( v, i - e ) + 1;  e := i  END;
 					INC( i )
 				END;
 				FOR i := 1 TO e DO  res := mg.Mult( res, res )  END;
@@ -688,47 +796,6 @@ VAR
 	END ModExp;
 
 
-	PROCEDURE Zero*( VAR x: BigNumber ): BOOLEAN;
-	BEGIN
-		RETURN (x.len = 0) OR ((x.len = 1) & (x.d[0] = 0))
-	END Zero;
-
-	PROCEDURE Dec*( VAR x: BigNumber );
-	VAR i: INTEGER;
-	BEGIN
-		i := 0;
-		IF Zero( x ) THEN  x.len := 1;  x.neg := TRUE;  x.d[0] := 1
-		ELSIF x.neg THEN
-			WHILE (x.d[i] = -1) & (i < x.len) DO  x.d[i] := 0;  INC( i )  END;
-			IF i = x.len THEN  x.d[i] := 1;  INC( x.len )  ELSE  INC( x.d[i] )  END
-		ELSE
-			WHILE x.d[i] = 0 DO  x.d[i] := -1;  INC( i )  END;
-			DEC( x.d[i] );  fixlen( x.d, x.len )
-		END
-	END Dec;
-
-	PROCEDURE Inc*( VAR x: BigNumber );
-	VAR i: INTEGER;
-	BEGIN
-		i := 0;
-		IF ~x.neg THEN
-			WHILE (x.d[i] = -1) & (i < x.len) DO  x.d[i] := 0;  INC( i )  END;
-			IF i = x.len THEN  x.d[i] := 1;  INC( x.len )  ELSE  INC( x.d[i] )  END
-		ELSE
-			WHILE x.d[i] = 0 DO  x.d[i] := -1;  INC( i )  END;
-			DEC( x.d[i] );  fixlen( x.d, x.len );
-			IF x.len = 0 THEN  x.neg := FALSE  END
-		END
-	END Inc;
-
-	PROCEDURE Mask*( VAR x: BigNumber; bits: INTEGER );
-	VAR w, b: INTEGER;
-	BEGIN
-		w := bits DIV 32;  b := bits MOD 32;  x.len := w;
-		IF b # 0 THEN  INC( x.len );
-			x.d[w] := S.VAL( LONGINT,  S.VAL( SET, x.d[w] ) * {0..b} )
-		END
-	END Mask;
 
 	PROCEDURE GCD*( a, b: BigNumber ): BigNumber;		(**  gcd( a, b ) *)
 	VAR x, y, r: BigNumber;
@@ -737,9 +804,9 @@ VAR
 		Copy( a, x );  Copy( b, y );
 		LOOP
 			IF Cmp( x, y ) > 0 THEN  x := Mod( x, y );
-				IF Zero( x ) THEN  Copy( y, r );  RETURN r  END
+				IF x.IsZero( ) THEN  Copy( y, r );  EXIT  END
 			ELSE  y := Mod( y, x ) ;
-				IF Zero( y ) THEN  Copy( x, r );  RETURN r  END
+				IF y.IsZero( ) THEN  Copy( x, r );  EXIT  END
 			END;
 		END;
 		RETURN r
@@ -754,10 +821,10 @@ VAR
 		p := 0;  i := 1;  s := 2;  n := 0;
 		LOOP
 			Div2( g[p], g[i], q, g[s] );  t := Mul( q, v[i] );  v[s] := Add( v[p], t );  INC( n );
-			IF Zero( g[s] ) THEN  EXIT  END;
+			IF g[s].IsZero( ) THEN  EXIT  END;
 			tmp := p;  p := i;  i := s;  s := tmp;
 		END;
-		IF (g[i].len = 1 ) & (g[i].d[0] = 1) THEN
+		IF (g[i].len = 1) & (g[i].d[0] = 1) THEN
 			IF ODD( n ) THEN  v[i] := Sub( m, v[i] )  END;
 			x := Mod( v[i], m )
 		ELSE  AssignInt( x, 0 )
@@ -765,49 +832,12 @@ VAR
 		RETURN x
 	END ModInverse;
 
-	PROCEDURE Shift*( VAR x: BigNumber;  n: INTEGER );
-	VAR right: BOOLEAN;  w, bits, i, l: INTEGER;  a, b: LONGINT;
-	BEGIN
-		IF x.len = 0 THEN  RETURN  END;
-		IF n < 0 THEN  right := TRUE;  n := ABS( n )  ELSE  right := FALSE  END;
-		w := n DIV 32;  bits := n MOD 32;
-		IF ~right THEN  adjust( x.d, x.len, x.len + w + 1 );
-			IF w > 0 THEN
-				FOR i := x.len - 1 TO 0 BY -1 DO  x.d[i + w] := x.d[i]  END;
-				FOR i := 0 TO w - 1 DO  x.d[i] := 0  END;
-				INC( x.len, w )
-			END;
-			IF bits > 0 THEN  x.d[x.len] := 0;
-				FOR i := x.len TO 0 BY -1 DO  a := x.d[i];
-					IF i > 0 THEN  b := x.d[i - 1]  ELSE  b := 0  END;
-					x.d[i] := LSH( a, bits ) + LSH( b, -32 + bits )
-				END;
-				IF x.d[x.len] # 0 THEN  INC( x.len )  END;
-			END
-		ELSE
-			IF w > 0 THEN
-				FOR i := 0 TO x.len - w - 1 DO  x.d[i] := x.d[i + w]  END;
-				DEC( x.len, w )
-			END;
-			IF bits > 0 THEN  l := x.len;
-				FOR i := 0 TO  l - 1 DO  a := x.d[i];
-					IF i < l - 1 THEN  b := x.d[i + 1]  ELSE  b := 0  END;
-					x.d[i] := LSH( a, -bits ) + LSH( b, 32 - bits )
-				END;
-				IF x.d[l - 1] = 0 THEN  DEC( x.len )  END;
-			END
-		END;
-	END Shift;
 
-	PROCEDURE Neg*( VAR x: BigNumber );
-	BEGIN
-		x.neg := ~x.neg
-	END Neg;
 
 	(*--------------------------- Text I/O ---------------------------------*)
 
 	PROCEDURE TextWrite*( w: Streams.Writer;  b: BigNumber );
-	VAR i: INTEGER;
+	VAR i: LONGINT;
 	BEGIN
 		IF b.neg THEN  w.String( "-" ) END;
 		IF b.len = 0 THEN  w.String( " 00000000" )
@@ -849,12 +879,15 @@ VAR
 	BEGIN
 		REPEAT
 			REPEAT r.Char( c ) UNTIL (c > ' ') OR (r.Available() = 0);
-		UNTIL (r.Available() = 0) OR (c >= '0') & (c <= '9') OR (c >= 'A') & (c <= 'F') OR (c >= 'a') & (c <= 'f') OR (c = '.');
+		UNTIL	(r.Available() = 0) OR 
+				(c >= '0') & (c <= '9') OR 
+				(c >= 'A') & (c <= 'F') OR 
+				(c >= 'a') & (c <= 'f') OR (c = '.');
 		RETURN c
 	END nibble;
 
 	PROCEDURE TextRead*( r: Streams.Reader;  VAR b: BigNumber );
-	VAR buf: ARRAY 2048 OF CHAR; i: INTEGER; n: CHAR;
+	VAR buf: ARRAY 2048 OF CHAR; i: LONGINT; n: CHAR;
 	BEGIN
 		i := 0;  n := nibble( r );
 		WHILE n # '.' DO buf[i] := n;  INC( i );  n := nibble( r ) END;
@@ -866,22 +899,23 @@ VAR
 	(*--------------------------- File I/O ---------------------------------*)
 
 	PROCEDURE FileRead*( r: Streams.Reader;  VAR b: BigNumber );
-	VAR i, j: INTEGER;
+	VAR i, j: LONGINT;
 	BEGIN
-		r.RawInt( j );
+		r.RawLInt( j );
 		NEW( b, 32 * j );
 		b.len := j;
 		FOR i := 0 TO j - 1 DO  r.RawLInt( b.d[ i ] )  END
 	END FileRead;
 
 	PROCEDURE FileWrite*( w: Streams.Writer;  b: BigNumber );
-	VAR i, j: INTEGER;
+	VAR i, j: LONGINT;
 	BEGIN
 		j := b.len;
-		w.RawInt( j );
+		w.RawLInt( j );
 		FOR i := 0 TO j - 1 DO  w.RawLInt( b.d[ i ] )  END
 	END FileWrite;
 
+
 	(* ------------ buffer pooling to make this module thread-save (F.N.) -----------------------*)
 
 	PROCEDURE GetBuffer( ): digits;

source/CryptoDSA.Mod

@@ -91,7 +91,7 @@ VAR
 			FOR i := 0 TO 19 DO  sbuf[i] := seed[i]  END;
 		END;
 		B.AssignInt( test, 1 );
-		B.Shift( test, bits - 1 );
+		test.Shift( bits - 1 );
 		NEW( h );
 		pfound := FALSE;
 		LOOP (* find q and p *)
@@ -138,14 +138,14 @@ VAR
 					h.Update( buf, 0, 20 );
 					h.GetHash( md, 0 );
 					B.AssignBin( r0, md, 0, 20 );
-					B.Shift( r0, 160*k );  W := B.Add( W, r0 );
+					r0.Shift( 160*k );  W := B.Add( W, r0 );
 				END;
-				B.Mask( W, bits - 1);
+				W.Mask( bits - 1);
 				W := B.Add( W, test );
 				B.Copy( dsa.q, r0 );
-				B.Shift( r0, 1 );
+				r0.Shift( 1 );
 				r0 := B.Mod( W, r0 );
-				B.Dec( r0 );
+				r0.Dec;
 				dsa.p := B.Sub( W, r0 );
 				IF B.Cmp( dsa.p, test ) >= 0 THEN
 					IF P.IsPrime( dsa.p, 50, TRUE ) THEN
@@ -160,13 +160,13 @@ VAR
 		END; (* find q and p *)
 
 		B.Copy( dsa.p, test );
-		B.Dec( test );
+		test.Dec;
 		r0 := B.Div( test, dsa.q );	(*  r0 := (p-1)/q *)
 		B.AssignInt( test, 2 );
 		LOOP (* g := test ^ r0 mod p *)
 			dsa.g := B.ModExp( test, r0, dsa.p );
 			IF B.Cmp( dsa.g, one ) # 0 THEN  EXIT  END;
-			B.Inc( test );
+			test.Inc;
 		END;
 	END GenParams;
 
@@ -176,7 +176,7 @@ VAR
 		GenParams( priv, bits, seed );
 		REPEAT
 			priv.y := B.NewRandRange( priv.q )
-		UNTIL ~B.Zero( priv.y );
+		UNTIL ~priv.y.IsZero( );
 		NEW( pub );  pub^ := priv^;
 		pub.y := B.ModExp( priv.g, priv.y, priv.p );
 		priv.private := TRUE;

source/CryptoPrimes.Mod

@@ -14,7 +14,7 @@ TYPE
 	BigNumber = B.BigNumber;
 
 VAR
-	one, two: BigNumber;
+	one: BigNumber;
 	primes: ARRAY N OF LONGINT;
 
 
@@ -31,7 +31,7 @@ VAR
 				ELSE
 					Out.Int( i, 0 );  INC( i );
 					(* for "safe prime" generation, check that (p-1)/2 is prime. *)
-					B.Copy( p, t );  B.Shift( t, -1 );
+					B.Copy( p, t );  t.Shift( -1 );
 					IF IsPrime( t, checks, FALSE ) THEN
 						Out.String( " (safe prime)" ); Out.Ln;
 						RETURN p
@@ -53,7 +53,7 @@ VAR
 			IF IsPrime( p, checks, FALSE ) THEN
 				IF ~safe THEN  RETURN p
 				ELSE  (* for "safe prime" generation, check that (p-1)/2 is prime. *)
-					B.Copy( p, t );  B.Shift( t, -1 );
+					B.Copy( p, t );  t.Shift( -1 );
 					IF IsPrime( t, checks, FALSE ) THEN  RETURN p  END
 				END
 			END
@@ -117,7 +117,7 @@ VAR
 
 		(* we need (p - rem) mod add = 0 *)
 		r := B.Mod( p, add );  p := B.Sub( p, r );
-		IF B.Zero( rem ) THEN  B.Inc( p )  ELSE  p := B.Add( p, rem )  END;
+		IF rem.IsZero( ) THEN  p.Inc  ELSE  p := B.Add( p, rem )  END;
 
 		(* we now have a random number 'p' to test. *)
 		i := 0;
@@ -125,30 +125,30 @@ VAR
 			INC( i );
 			IF i >= N THEN  RETURN p  END;
 			B.AssignInt( d, primes[i] );  r := B.Mod( p, d );
-			IF B.Zero( r ) THEN  p := B.Add( p, add );  i := 0  END;
+			IF r.IsZero( ) THEN  p := B.Add( p, add );  i := 0  END;
 		END
 	END ProbableDHPrime;
 
 	PROCEDURE ProbableDHPrimeSafe( bits: INTEGER; padd, rem: BigNumber ): BigNumber;
 	VAR d, q, r, qr, qadd, p: BigNumber;  i: LONGINT;
 	BEGIN
-		B.Copy( padd, qadd );  B.Shift( qadd, -1 );
+		B.Copy( padd, qadd );  qadd.Shift( -1 );
 		q := B.NewRand( bits, 0, 1 );
 
 		r := B.Mod( q, qadd );  q := B.Sub( q, r );
-		IF B.Zero( rem ) THEN  B.Inc( q )
-		ELSE  B.Copy( rem, r );  B.Shift( r, -1 );  q := B.Add( q, r )
+		IF rem.IsZero( ) THEN  q.Inc
+		ELSE  B.Copy( rem, r );  r.Shift( -1 );  q := B.Add( q, r )
 		END;
 
 		(* we now have a random number  to test. *)
-		B.Copy( q, p );  B.Shift( p, 1 );  B.Inc( p );
+		B.Copy( q, p );  p.Shift( 1 );  p.Inc;
 
 		i := 0;
 		LOOP
 			INC( i );
 			IF i >= N THEN  RETURN p  END;
 			B.AssignInt( d, primes[i] );  r := B.Mod( p, d );  qr := B.Mod( q, d );
-			IF B.Zero( r ) OR B.Zero( qr ) THEN
+			IF r.IsZero( ) OR qr.IsZero( ) THEN
 				p := B.Add( p, padd );  q := B.Add( q, qadd );  i := 0
 			END;
 		END
@@ -158,7 +158,7 @@ VAR
 	PROCEDURE IsPrime*( a: BigNumber;  checks: INTEGER;  doTrialDiv: BOOLEAN ): BOOLEAN;
 	VAR i, k: INTEGER;  A, A1, A1odd, check: BigNumber;
 	BEGIN
-		IF checks = 0 THEN  checks := Checks( B.BitSize( a ) )  END;
+		IF checks = 0 THEN  checks := Checks( a.BitSize( ) )  END;
 		IF ~ODD( a.d[0] ) THEN  RETURN FALSE  END;
 		IF doTrialDiv THEN
 			FOR i := 1 TO N - 1 DO
@@ -166,18 +166,18 @@ VAR
 			END
 		END;
 		B.Copy( a, A );
-		IF A.neg THEN  B.Neg( A )  END;
-		B.Copy( A, A1 );  B.Dec( A1 );
-		IF B.Zero( A1 ) THEN  RETURN FALSE  END;
+		IF A.neg THEN  A.Negate  END;
+		B.Copy( A, A1 );  A1.Dec;
+		IF A1.IsZero( ) THEN  RETURN FALSE  END;
 
 		(* write  A1  as  A1odd * 2^k *)
-		k := 1;  WHILE ~B.BitSet( A1, k ) DO  INC( k )  END;
-		B.Copy( A1, A1odd );  B.Shift( A1odd, -k );
+		k := 1;  WHILE ~A1.BitSet( k ) DO  INC( k )  END;
+		B.Copy( A1, A1odd );  A1odd.Shift( -k );
 
 		FOR i := 1 TO checks DO
-			check := B.NewRand( B.BitSize( A1 ), 0, 0 );
-			IF B.Cmp( check, A1 ) >= 0 THEN  check := B.Sub( check, A1 )  END;
-			B.Inc( check );
+			check := B.NewRand( A1.BitSize( ), 0, 0 );
+			IF check.GEQ( A1 ) THEN  check := B.Sub( check, A1 )  END;
+			check.Inc;
 			(* now 1 <= check < A *)
 			IF ~witness( check, A, A1, A1odd, k ) THEN   RETURN FALSE  END;
 		END;
@@ -188,14 +188,14 @@ VAR
 	VAR w: BigNumber;
 	BEGIN
 		w := B.ModExp( W, a1odd, a );
-		IF B.Cmp( w, one ) = 0 THEN  (* probably prime *)  RETURN TRUE  END;
-		IF B.Cmp( w, a1 ) = 0 THEN   RETURN TRUE  END;
+		IF w.EQ( one ) THEN  (* probably prime *)  RETURN TRUE  END;
+		IF w.EQ( a1 ) THEN   RETURN TRUE  END;
 				(* w = -1 (mod a), a is probably prime *)
 		WHILE k > 0 DO
 			w := B.ModMul( w, w, a );  (* w = w^2 mod a *)
-			IF B.Cmp( w, one ) = 0 THEN  RETURN FALSE  END;
+			IF w.EQ( one ) THEN  RETURN FALSE  END;
 					(* a is composite, otherwise a previous w would  have been = -1 (mod a) *)
-			IF B.Cmp( w, a1 ) = 0 THEN  RETURN TRUE  END;
+			IF w.EQ( a1 ) THEN  RETURN TRUE  END;
 					(* w = -1 (mod a), a is probably prime *)
 			DEC( k )
 		END;
@@ -220,6 +220,6 @@ VAR
 	END Init;
 
 BEGIN
-	Init;  B.AssignInt( one, 1 ); B.AssignInt( two, 2 );
+	Init;  B.AssignInt( one, 1 ); 
 END CryptoPrimes.
 

source/CryptoRSA.Mod

@@ -25,14 +25,14 @@ TYPE
 		VAR
 			name-: ARRAY 128 OF CHAR;   (** Owner of this key. *)
 			private-: BOOLEAN;   (** Is this a private key? then the exponent is encrypted *)
-			size-: INTEGER;
+			size-: LONGINT;
 			exponent-, modulus-: Number;
 			p, q, u: Number;   (* for chinese remainder theorem *)
 			time-, date-: LONGINT;
 			certificates*: Certificate;
 			next*: Key;
 
-			PROCEDURE Sign*( CONST digest: ARRAY OF CHAR;  dlen: INTEGER ): Number;
+			PROCEDURE Sign*( CONST digest: ARRAY OF CHAR;  dlen: LONGINT ): Number;
 			VAR msg: Number;
 			BEGIN
 				ASSERT( private );
@@ -45,10 +45,10 @@ TYPE
 			END Sign;
 
 
-			PROCEDURE Verify*( CONST digest: ARRAY OF CHAR;  dlen: INTEGER;  signature: Number ): BOOLEAN;
+			PROCEDURE Verify*( CONST digest: ARRAY OF CHAR;  dlen: LONGINT;  signature: Number ): BOOLEAN;
 			VAR
 				msg: Number;
-				i, l: INTEGER;
+				i, l: LONGINT;
 				buf: Buffer;
 			BEGIN
 				ASSERT(  ~private & (dlen >= 16) );
@@ -105,8 +105,8 @@ VAR
 	BEGIN
 		ASSERT( B.Cmp( p, q ) # 0 );
 		n := B.Mul( p, q );
-		B.Copy( p, p1 );  B.Dec( p1 );
-		B.Copy( q, q1 );  B.Dec( q1 );
+		B.Copy( p, p1 );  p1.Dec;
+		B.Copy( q, q1 );  q1.Dec;
 		x := B.Mul( p1, q1 );
 
 		d := B.ModInverse( e, x );
@@ -205,7 +205,7 @@ VAR
 		r.String( k.name );
 		r.RawBool( k.private );
 		ASSERT( k.private );
-		r.RawInt( k.size );
+		r.RawLInt( k.size );
 		r.RawLInt( k.time );
 		r.RawLInt( k.date );
 
@@ -259,7 +259,7 @@ VAR
 		ASSERT( k.private );
 		w.Char( '"' ); w.String( k.name ); w.Char( '"' );
 		w.RawBool( k.private );
-		w.RawInt( k.size );
+		w.RawLInt( k.size );
 		w.RawLInt( k.time );
 		w.RawLInt( k.date );
 

source/CryptoSHA1.Mod

@@ -25,10 +25,10 @@ TYPE
 
 		PROCEDURE Initialize*;
 		BEGIN
-			hash[0] := 067452301H;
+			hash[0] := LONGINT( 067452301H );
 			hash[1] := LONGINT( 0EFCDAB89H );
 			hash[2] := LONGINT( 098BADCFEH );
-			hash[3] := 010325476H;
+			hash[3] := LONGINT( 010325476H );
 			hash[4] := LONGINT( 0C3D2E1F0H );
 			Nl := 0;
 			Nh := 0;
@@ -165,7 +165,7 @@ TYPE
 		xc := U.SetFromBufferBE( buf, pos );  INC( pos, 4 );  tr0019( A, B, C, D, E, T, xc );
 		xd := U.SetFromBufferBE( buf, pos );  INC( pos, 4 );  tr0019( T, A, B, C, D, E, xd );
 		xe := U.SetFromBufferBE( buf, pos );  INC( pos, 4 );  tr0019( E, T, A, B, C, D, xe );
-		xf := U.SetFromBufferBE( buf, pos  );  INC( pos, 4 );  tr0019( D, E, T, A, B, C, xf  );
+		xf  := U.SetFromBufferBE( buf, pos );  INC( pos, 4 );  tr0019( D, E, T, A, B, C, xf  );
 
 		x0 := ROT( x0 / x2 / x8 / xd, 1 );		tr0019( C, D, E, T, A, B, x0 );
 		x1 := ROT( x1 / x3 / x9 / xe, 1 );		tr0019( B, C, D, E, T, A, x1 );
@@ -180,7 +180,7 @@ TYPE
 		x9 := ROT( x9 / xb / x1 / x6, 1 );		tr2039( T, A, B, C, D, E, x9 );
 		xa := ROT( xa / xc / x2 / x7, 1 ); 		tr2039( E, T, A, B, C, D, xa );
 		xb := ROT( xb / xd / x3 / x8, 1 );		tr2039( D, E, T, A, B, C, xb );
-		xc := ROT( xc / xe  / x4 / x9, 1 ); 		tr2039( C, D, E, T, A, B, xc );
+		xc := ROT( xc / xe / x4 / x9, 1 ); 		tr2039( C, D, E, T, A, B, xc );
 		xd := ROT( xd / xf  / x5 / xa, 1 );		tr2039( B, C, D, E, T, A, xd );
 		xe := ROT( xe / x0 / x6 / xb, 1 );		tr2039( A, B, C, D, E, T, xe );
 		xf  := ROT( xf  / x1 / x7 / xc, 1 );		tr2039( T, A, B, C, D, E, xf  );
@@ -197,7 +197,7 @@ TYPE
 		x9 := ROT( x9 / xb / x1 / x6, 1 );		tr4059( B, C, D, E, T, A, x9 );
 		xa := ROT( xa / xc / x2 / x7, 1 );		tr4059( A, B, C, D, E, T, xa );
 		xb := ROT( xb / xd / x3 / x8, 1 );		tr4059( T, A, B, C, D, E, xb );
-		xc := ROT( xc / xe  / x4 / x9, 1 );		tr4059( E, T, A, B, C, D, xc );
+		xc := ROT( xc / xe / x4 / x9, 1 );		tr4059( E, T, A, B, C, D, xc );
 		xd := ROT( xd / xf  / x5 / xa, 1 );  		tr4059( D, E, T, A, B, C, xd );
 		xe := ROT( xe / x0 / x6 / xb, 1 );  		tr4059( C, D, E, T, A, B, xe );
 		xf  := ROT( xf  / x1 / x7 / xc, 1 );		tr4059( B, C, D, E, T, A, xf  );
@@ -214,7 +214,7 @@ TYPE
 		xa := ROT( xa / xc / x2 / x7, 1 );		tr4059( C, D, E, T, A, B, xa );
 		xb := ROT( xb / xd / x3 / x8, 1 );		tr4059( B, C, D, E, T, A, xb );
 
-		xc := ROT( xc / xe / x4 / x9, 1 );			tr6079( A, B, C, D, E, T, xc );
+		xc := ROT( xc / xe / x4 / x9, 1 );		tr6079( A, B, C, D, E, T, xc );
 		xd := ROT( xd / xf  / x5 / xa, 1 );		tr6079( T, A, B, C, D, E, xd );
 		xe := ROT( xe / x0 / x6 / xb, 1 ); 		tr6079( E, T, A, B, C, D, xe );
 		xf  := ROT( xf  / x1 / x7 / xc, 1 );		tr6079( D, E, T, A, B, C, xf  );
@@ -230,7 +230,7 @@ TYPE
 		x9 := ROT( x9 / xb / x1 / x6, 1 );		tr6079( T, A, B, C, D, E, x9 );
 		xa := ROT( xa / xc / x2 / x7, 1 );		tr6079( E, T, A, B, C, D, xa );
 		xb := ROT( xb / xd / x3 / x8, 1 );		tr6079( D, E, T, A, B, C, xb );
-		xc := ROT( xc / xe  / x4 / x9, 1 );		tr6079( C, D, E, T, A, B, xc );
+		xc := ROT( xc / xe / x4 / x9, 1 );		tr6079( C, D, E, T, A, B, xc );
 		xd := ROT( xd / xf  / x5 / xa, 1 );		tr6079( B, C, D, E, T, A, xd );
 		xe := ROT( xe / x0 / x6 / xb, 1 );		tr6079( A, B, C, D, E, T, xe );
 		xf  := ROT( xf  / x1 / x7 / xc, 1 );		tr6079( T, A, B, C, D, E, xf  );