prepared for 64-bit compilation, SET --> SET32

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

source/CryptoAES.Mod

@@ -8,22 +8,22 @@ CONST
 	MaxRounds = 14;  
 	ECB = Ciphers.ECB;  CBC = Ciphers.CBC;  CTR = Ciphers.CTR;
 	
-	b0 = S.VAL( SET, 0000000FFH );  b1 = S.VAL( SET, 00000FF00H );  
-	b2 = S.VAL( SET, 000FF0000H );  b3 = S.VAL( SET, 0FF000000H );
+	b0 = S.VAL( SET32, 0000000FFH );  b1 = S.VAL( SET32, 00000FF00H );  
+	b2 = S.VAL( SET32, 000FF0000H );  b3 = S.VAL( SET32, 0FF000000H );
 
 TYPE
-	RTable = ARRAY 256 OF SET;
-	RKeys = ARRAY 4*(MaxRounds + 1) OF SET;
+	RTable = ARRAY 256 OF SET32;
+	RKeys = ARRAY 4*(MaxRounds + 1) OF SET32;
 	
 VAR
 	e0, e1, e2, e3, e4: RTable;
 	d0, d1, d2, d3, d4: RTable;
-	rcon: ARRAY 10 OF SET;   (* for 128-bit blocks, Rijndael never uses more than 10 rcon values *)
+	rcon: ARRAY 10 OF SET32;   (* for 128-bit blocks, Rijndael never uses more than 10 rcon values *)
 
 TYPE
 	Cipher* = OBJECT (Ciphers.Cipher)
 			TYPE
-				Block = ARRAY 4 OF SET;
+				Block = ARRAY 4 OF SET32;
 				Ind4 = RECORD a, b, c, d: LONGINT END;
 			VAR
 				rounds: SHORTINT;
@@ -52,7 +52,7 @@ TYPE
 					i := 4;
 					REPEAT
 						DEC( i );
-						x := S.VAL( LONGINT, iv[i] ) + 1;  iv[i] := S.VAL( SET, x )
+						x := S.VAL( LONGINT, iv[i] ) + 1;  iv[i] := S.VAL( SET32, x )
 					UNTIL (x # 0) OR (i = 0)
 				END IncIV;
 
@@ -158,7 +158,7 @@ TYPE
 					b[3] := (d4[t3.d]*b3)/(d4[t2.c]*b2)/(d4[t1.b]*b1)/(d4[t0.a]*b0)/dkey[p + 3];
 				END RoundD;
 				
-				PROCEDURE -split( s: SET;  VAR b: Ind4 );   (* split set into 4 indexes *)
+				PROCEDURE -split( s: SET32;  VAR b: Ind4 );   (* split set into 4 indexes *)
 				BEGIN
 					b.a := S.VAL( LONGINT, s ) MOD 100H;
 					b.b := S.VAL( LONGINT, s ) DIV 100H MOD 100H;
@@ -230,9 +230,9 @@ TYPE
 				
 				
 				PROCEDURE InvertKeys;
-				VAR i, j, k, p: LONGINT;  t: SET;  ib: Ind4;
+				VAR i, j, k, p: LONGINT;  t: SET32;  ib: Ind4;
 				
-					PROCEDURE ind( s: SET ): LONGINT;   (* extract index byte 0 *)
+					PROCEDURE ind( s: SET32 ): LONGINT;   (* extract index byte 0 *)
 					BEGIN
 						RETURN S.VAL( LONGINT, s ) MOD 100H
 					END ind;
@@ -282,7 +282,7 @@ TYPE
 
 		PROCEDURE xor( a, b: LONGINT ): LONGINT;
 		BEGIN
-			RETURN S.VAL( LONGINT, S.VAL( SET, a ) / S.VAL( SET, b ) )
+			RETURN S.VAL( LONGINT, S.VAL( SET32, a ) / S.VAL( SET32, b ) )
 		END xor;
 		
 		PROCEDURE f1( x: LONGINT ): LONGINT;
@@ -316,21 +316,21 @@ TYPE
 			i2 := f1( i1 );  i4 := f1( i2 );  i8 := f1( i4 );  i9 := xor( i8, i1 );  
 			ib := xor( i9, i2 );  id := xor( i9, i4 );  ie := xor( i8, xor( i4, i2 ) );
 
-			e0[i1] := S.VAL( SET, ((v2*100H + v1)*100H + v1)*100H + v3 );
-			e1[i1] := S.VAL( SET, ((v3*100H + v2)*100H + v1)*100H + v1 );
-			e2[i1] := S.VAL( SET, ((v1*100H + v3)*100H + v2)*100H + v1 );
-			e3[i1] := S.VAL( SET, ((v1*100H + v1)*100H + v3)*100H + v2 );
-			e4[i1] := S.VAL( SET, ((v1*100H + v1)*100H + v1)*100H + v1 );
+			e0[i1] := S.VAL( SET32, ((v2*100H + v1)*100H + v1)*100H + v3 );
+			e1[i1] := S.VAL( SET32, ((v3*100H + v2)*100H + v1)*100H + v1 );
+			e2[i1] := S.VAL( SET32, ((v1*100H + v3)*100H + v2)*100H + v1 );
+			e3[i1] := S.VAL( SET32, ((v1*100H + v1)*100H + v3)*100H + v2 );
+			e4[i1] := S.VAL( SET32, ((v1*100H + v1)*100H + v1)*100H + v1 );
 
-			d0[v1] := S.VAL( SET, ((ie*100H + i9)*100H + id)*100H + ib );
-			d1[v1] := S.VAL( SET, ((ib*100H + ie)*100H + i9)*100H + id );
-			d2[v1] := S.VAL( SET, ((id*100H + ib)*100H + ie)*100H + i9 );
-			d3[v1] := S.VAL( SET, ((i9*100H + id)*100H + ib)*100H + ie );
-			d4[v1] := S.VAL( SET, ((i1*100H + i1)*100H + i1)*100H + i1 );
+			d0[v1] := S.VAL( SET32, ((ie*100H + i9)*100H + id)*100H + ib );
+			d1[v1] := S.VAL( SET32, ((ib*100H + ie)*100H + i9)*100H + id );
+			d2[v1] := S.VAL( SET32, ((id*100H + ib)*100H + ie)*100H + i9 );
+			d3[v1] := S.VAL( SET32, ((i9*100H + id)*100H + ib)*100H + ie );
+			d4[v1] := S.VAL( SET32, ((i1*100H + i1)*100H + i1)*100H + i1 );
 		END;
 		t := 1;
 		FOR i1 := 0 TO 9 DO
-			rcon[i1] := S.VAL( SET, ASH( t, 24 ) );
+			rcon[i1] := S.VAL( SET32, ASH( t, 24 ) );
 			t := f1( t );
 		END;
 	END Initialize;

source/CryptoBigNumbers.Mod

@@ -37,7 +37,7 @@ TYPE
 				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} )
+						d[w] := S.VAL( LONGINT,  S.VAL( SET32, d[w] ) * {0..b} )
 					END
 				END Mask;
 
@@ -157,7 +157,7 @@ TYPE
 				BEGIN
 					w := n DIV 32;  bit := n MOD 32;
 					IF w >= len THEN  RETURN FALSE
-					ELSE  RETURN  bit IN S.VAL( SET, d[w] )
+					ELSE  RETURN  bit IN S.VAL( SET32, d[w] )
 					END
 				END BitSet;
 
@@ -277,7 +277,7 @@ VAR
 
 	(** random number with len 'bits' *)
 	PROCEDURE NewRand*( bits: LONGINT;  top, bottom: SHORTINT ): BigNumber;
-	VAR n, len, i, topbit: LONGINT;  topword: SET;  b: BigNumber;
+	VAR n, len, i, topbit: LONGINT;  topword: SET32;  b: BigNumber;
 	BEGIN
 		len := bits;  INC( len, (-len) MOD 32 );
 		NEW( b, len );
@@ -287,7 +287,7 @@ VAR
 		END;
 		b.len := (bits + 31) DIV 32;
 		topbit := (bits - 1)  MOD 32;
-		topword := S.VAL( SET, b.d[b.len - 1] ) * {0..topbit};
+		topword := S.VAL( SET32, b.d[b.len - 1] ) * {0..topbit};
 		IF top > 0 THEN INCL( topword, topbit ) END;
 		b.d[b.len - 1] := S.VAL( LONGINT, topword );
 		IF (bottom > 0) & ~ODD( b.d[0] ) THEN  INC( b.d[0] )  END;
@@ -411,7 +411,7 @@ VAR
 
 	PROCEDURE Invert( x: LONGINT ): LONGINT;
 	BEGIN
-		RETURN S.VAL( LONGINT, -S.VAL( SET, x ) )
+		RETURN S.VAL( LONGINT, -S.VAL( SET32, x ) )
 	END Invert;
 
 	PROCEDURE add( a, b: digits; VAR c: digits;  al, bl: LONGINT;  VAR cl: LONGINT );
@@ -569,12 +569,12 @@ VAR
 		ELSE bit := 63
 		END;
 		q := 0;  r := 0;
-		WHILE (bit >= 0) & ~(bit MOD 32 IN S.VAL( SET, a[bit DIV 32]) ) DO  DEC( bit )  END;
+		WHILE (bit >= 0) & ~(bit MOD 32 IN S.VAL( SET32, a[bit DIV 32]) ) DO  DEC( bit )  END;
 		WHILE bit >= 0 DO
 			overflow := r < 0;  r := ASH( r, 1 );
-			IF bit MOD 32 IN S.VAL( SET, a[bit DIV 32] ) THEN  INC( r )  END;
+			IF bit MOD 32 IN S.VAL( SET32, a[bit DIV 32] ) THEN  INC( r )  END;
 			IF overflow OR LessOrEqual( b, r ) THEN  r := r - b;
-				IF bit < 32 THEN  INCL( S.VAL( SET, q ), bit )  ELSE  q := -1  END;
+				IF bit < 32 THEN  INCL( S.VAL( SET32, q ), bit )  ELSE  q := -1  END;
 			END;
 			DEC( bit )
 		END;
@@ -605,14 +605,14 @@ VAR
 		ELSE  bit := 95
 		END;
 		q := 0;  r[0] := 0;  r[1] := 0;
-		WHILE (bit >= 0) & ~(bit MOD 32 IN S.VAL( SET, a[bit DIV 32]) ) DO  DEC( bit )  END;
+		WHILE (bit >= 0) & ~(bit MOD 32 IN S.VAL( SET32, a[bit DIV 32]) ) DO  DEC( bit )  END;
 		WHILE bit >= 0 DO
 			shift( r );	(* r := r*2 *)
-			IF bit MOD 32 IN S.VAL( SET, a[bit DIV 32] ) THEN  INC( r[0] )  END;
+			IF bit MOD 32 IN S.VAL( SET32, a[bit DIV 32] ) THEN  INC( r[0] )  END;
 			IF overflow OR ge( r, b ) THEN
 				borrow := LessOrEqual( r[0], b[0] );  r[0] := r[0] - b[0];  r[1] := r[1] - b[1];
 				IF borrow  THEN  DEC( r[1] )  END;
-				IF bit < 32 THEN  INCL( S.VAL( SET, q ), bit )  ELSE  q := -1  END;
+				IF bit < 32 THEN  INCL( S.VAL( SET32, q ), bit )  ELSE  q := -1  END;
 			END;
 			DEC( bit )
 		END;

source/CryptoBlowfish.Mod

@@ -12,11 +12,11 @@ CONST
 	N = 16;  
 
 TYPE
-	TP = ARRAY N + 2 OF SET;
+	TP = ARRAY N + 2 OF SET32;
 	TS = RECORD 
 			a	: ARRAY 256 OF LONGINT;
 			b	: ARRAY 256 OF LONGINT;
-			c	: ARRAY 256 OF SET;
+			c	: ARRAY 256 OF SET32;
 			d	: ARRAY 256 OF LONGINT;
 		END;
 
@@ -28,10 +28,10 @@ TYPE
 			VAR
 				p: TP;
 				s: TS;
-				ivl, ivr: SET;
+				ivl, ivr: SET32;
 
 				PROCEDURE InitKey*( CONST src: ARRAY OF CHAR; keybits: LONGINT );
-				VAR i, m: LONGINT;  xl, xr: SET;
+				VAR i, m: LONGINT;  xl, xr: SET32;
 				BEGIN
 					InitKey^( src, keybits );  m := keybits DIV 8;  s := s0;
 					FOR i := 0 TO N + 1 DO  
@@ -82,7 +82,7 @@ TYPE
 				END Decrypt;
 
 				PROCEDURE EncryptBlock( VAR buf: ARRAY OF CHAR;  pos: LONGINT );
-				VAR xl, xr, yl, yr: SET;
+				VAR xl, xr, yl, yr: SET32;
 				BEGIN
 					xl := U.SetFromBufferBE( buf, pos );  xr := U.SetFromBufferBE( buf, pos + 4 );
 					IF mode = Ciphers.CBC THEN  xl := xl/ivl;  xr := xr/ivr  END;
@@ -92,7 +92,7 @@ TYPE
 				END EncryptBlock;
 
 				PROCEDURE DecryptBlock( VAR buf: ARRAY OF CHAR;  pos: LONGINT );
-				VAR xl, xr, yl, yr: SET;
+				VAR xl, xr, yl, yr: SET32;
 				BEGIN
 					xl := U.SetFromBufferBE( buf, pos );  xr := U.SetFromBufferBE( buf, pos + 4 );
 					decrypt0( xl, xr, yl, yr );
@@ -101,18 +101,18 @@ TYPE
 				END DecryptBlock;
 				
 				
-				PROCEDURE F( x: LONGINT ): SET;
+				PROCEDURE F( x: LONGINT ): SET32;
 				VAR 
-					ab, c: SET; d: LONGINT; 
+					ab, c: SET32; d: LONGINT; 
 				BEGIN
-					ab := S.VAL( SET, s.a[x DIV 1000000H MOD 100H] + s.b[x DIV 10000H MOD 100H] );
+					ab := S.VAL( SET32, s.a[x DIV 1000000H MOD 100H] + s.b[x DIV 10000H MOD 100H] );
 					c := s.c[x DIV 100H MOD 100H];
 					d := s.d[x MOD 100H];
-					RETURN S.VAL( SET, S.VAL( LONGINT, ab/c ) + d );
+					RETURN S.VAL( SET32, S.VAL( LONGINT, ab/c ) + d );
 				END F;
 
-				PROCEDURE encrypt0( xl, xr: SET;  VAR yl, yr: SET );
-				VAR t: SET;  i: INTEGER;
+				PROCEDURE encrypt0( xl, xr: SET32;  VAR yl, yr: SET32 );
+				VAR t: SET32;  i: INTEGER;
 				BEGIN
 					FOR i := 0 TO N - 1 DO
 						xl := xl/p[i];  xr := F( S.VAL( LONGINT, xl ) )/xr;
@@ -122,8 +122,8 @@ TYPE
 					yr := xr/p[N];  yl := xl/p[N + 1];
 				END encrypt0;
 
-				PROCEDURE decrypt0( xl, xr: SET;  VAR yl, yr: SET );
-				VAR t: SET;  i: INTEGER;
+				PROCEDURE decrypt0( xl, xr: SET32;  VAR yl, yr: SET32 );
+				VAR t: SET32;  i: INTEGER;
 				BEGIN
 					FOR i := N + 1 TO 2 BY -1 DO
 						xl := xl/p[i];  xr := F( S.VAL( LONGINT, xl ) )/xr;

source/CryptoCAST.Mod

@@ -15,11 +15,11 @@ TYPE
 				data: ARRAY 16 OF Key
 			END;
 
-	Block = ARRAY 2 OF SET;
+	Block = ARRAY 2 OF SET32;
 
 VAR
 	T0, T1, T2, T3: ARRAY 256 OF LONGINT;
-	T4, T5, T6, T7: ARRAY 256 OF SET;
+	T4, T5, T6, T7: ARRAY 256 OF SET32;
 
 TYPE
 	Cipher* = OBJECT (Ciphers.Cipher)
@@ -96,12 +96,12 @@ TYPE
 
 	PROCEDURE InitKeys( VAR keys: Keys;  CONST src: ARRAY OF CHAR;  len: LONGINT );
 	VAR buf: ARRAY 16 OF CHAR;
-		X, Z: ARRAY 4 OF SET;
+		X, Z: ARRAY 4 OF SET32;
 		x, z: ARRAY 16 OF INTEGER;
-		k: ARRAY 32 OF SET;
+		k: ARRAY 32 OF SET32;
 		i, j: LONGINT;
 
-		PROCEDURE Zz( i: INTEGER;  s: SET );
+		PROCEDURE Zz( i: INTEGER;  s: SET32 );
 		VAR l: LONGINT;
 		BEGIN
 			Z[i DIV 4] := s;  l := S.VAL( LONGINT, s );
@@ -111,7 +111,7 @@ TYPE
 			z[i + 0] := SHORT( l MOD 256 );
 		END Zz;
 
-		PROCEDURE Xx( i: INTEGER;  s: SET );
+		PROCEDURE Xx( i: INTEGER;  s: SET32 );
 		VAR l: LONGINT;
 		BEGIN
 			X[i DIV 4] := s;  l := S.VAL( LONGINT, s );
@@ -177,7 +177,7 @@ TYPE
 		END
 	END InitKeys;
 
-	PROCEDURE CAST1( VAR k: Key;  VAR L, R: SET );   (* +, xor, - *)
+	PROCEDURE CAST1( VAR k: Key;  VAR L, R: SET32 );   (* +, xor, - *)
 	VAR a, b, axb, t, c, d: LONGINT;
 	BEGIN
 		t := ROT( k.val + S.VAL( LI, R ), k.rot );
@@ -185,22 +185,22 @@ TYPE
 		a := T0[t MOD 256];  t := t DIV 256;
 		d := T3[t MOD 256];  t := t DIV 256;
 		c := T2[t MOD 256];
-		axb := S.VAL( LI, S.VAL( SET, a ) / S.VAL( SET, b ) );
-		L := L / S.VAL( SET, axb - c + d );
+		axb := S.VAL( LI, S.VAL( SET32, a ) / S.VAL( SET32, b ) );
+		L := L / S.VAL( SET32, axb - c + d );
 	END CAST1;
 
-	PROCEDURE CAST2( VAR k: Key;  VAR L, R: SET );   (* xor, -, + *)
+	PROCEDURE CAST2( VAR k: Key;  VAR L, R: SET32 );   (* xor, -, + *)
 	VAR t, a, b, c, d: LONGINT;
 	BEGIN
-		t := ROT( S.VAL( LI, S.VAL( SET, k.val )/R ), k.rot );
+		t := ROT( S.VAL( LI, S.VAL( SET32, k.val )/R ), k.rot );
 		b := T1[t MOD 256];  t := t DIV 256;
 		a := T0[t MOD 256];  t := t DIV 256;
 		d := T3[t MOD 256];  t := t DIV 256;
 		c := T2[t MOD 256];  
-		L := L / (S.VAL( SET, a - b + c ) / S.VAL( SET, d ) );
+		L := L / (S.VAL( SET32, a - b + c ) / S.VAL( SET32, d ) );
 	END CAST2;
 
-	PROCEDURE CAST3( VAR k: Key;  VAR L, R: SET );   (* -, +, xor *)
+	PROCEDURE CAST3( VAR k: Key;  VAR L, R: SET32 );   (* -, +, xor *)
 	VAR t, a, b, c, d: LONGINT;
 	BEGIN
 		t := ROT( k.val - S.VAL( LI, R ), k.rot );
@@ -208,13 +208,13 @@ TYPE
 		a := T0[t MOD 256];  t := t DIV 256;
 		d := T3[t MOD 256];  t := t DIV 256;
 		c := T2[t MOD 256];  
-		L := L / S.VAL( SET, S.VAL( LI, S.VAL( SET, a + b ) / S.VAL( SET, c ) ) - d );
+		L := L / S.VAL( SET32, S.VAL( LI, S.VAL( SET32, a + b ) / S.VAL( SET32, c ) ) - d );
 	END CAST3;
 
 
 
 	PROCEDURE encrypt( VAR k: Keys;  VAR b: Block );
-	VAR l, r: SET;
+	VAR l, r: SET32;
 	BEGIN
 		l := b[0];  r := b[1];
 		CAST1( k.data[0], l, r );  CAST2( k.data[  1], r, l );  CAST3( k.data[  2], l, r );
@@ -229,7 +229,7 @@ TYPE
 	END encrypt;
 
 	PROCEDURE decrypt( VAR k: Keys;  VAR b: Block );
-	VAR l, r: SET;
+	VAR l, r: SET32;
 	BEGIN
 		l := b[0];  r := b[1];
 		IF ~k.short THEN

source/CryptoDES.Mod

@@ -6,15 +6,15 @@ MODULE CryptoDES;	(** AUTHOR "G.F."; PUROSE "DES Cipher";	 *)
 
 IMPORT S := SYSTEM, U := CryptoUtils, Ciphers := CryptoCiphers;
 CONST 
-	Mask01 = S.VAL( SET, 0AAAAAAAAH );
-	Mask02 = S.VAL( SET, 33333333H );
-	Mask04 = S.VAL( SET, 0F0F0F0FH );
-	Mask08 = S.VAL( SET, 00FF00FFH );
-	Mask16 = S.VAL( SET, 0000FFFFH );
+	Mask01 = S.VAL( SET32, 0AAAAAAAAH );
+	Mask02 = S.VAL( SET32, 33333333H );
+	Mask04 = S.VAL( SET32, 0F0F0F0FH );
+	Mask08 = S.VAL( SET32, 00FF00FFH );
+	Mask16 = S.VAL( SET32, 0000FFFFH );
 
 TYPE
-	Sandbox = ARRAY 64 OF SET;
-	BitSwap = ARRAY 16 OF SET;
+	Sandbox = ARRAY 64 OF SET32;
+	BitSwap = ARRAY 16 OF SET32;
 	Ind4* = RECORD a-, b-, c-, d-: LONGINT END;
 	
 VAR
@@ -24,11 +24,11 @@ VAR
 TYPE 
 	Cipher* = OBJECT (Ciphers.Cipher)		
 	VAR
-		ske, skd: ARRAY 32 OF SET;  ki: LONGINT;
-		ivx, ivy: SET;
+		ske, skd: ARRAY 32 OF SET32;  ki: LONGINT;
+		ivx, ivy: SET32;
 	
 		PROCEDURE InitKey*( CONST src: ARRAY OF CHAR;  keybits: LONGINT );
-		VAR X, Y: SET;  i: LONGINT;
+		VAR X, Y: SET32;  i: LONGINT;
 		BEGIN
 			ASSERT( keybits = 64 );
 			InitKey^( src, keybits );
@@ -52,7 +52,7 @@ TYPE
 		
 		
 		PROCEDURE  Encrypt* ( VAR buf: ARRAY OF CHAR; ofs, len: LONGINT );
-		VAR i, r: LONGINT;   X, Y: SET;
+		VAR i, r: LONGINT;   X, Y: SET32;
 		BEGIN
 			ASSERT( isKeyInitialized & (mode IN {Ciphers.ECB, Ciphers.CBC}) );
 			ASSERT( len MOD blockSize = 0 );   (* padding must have been added *)
@@ -74,7 +74,7 @@ TYPE
 		
 		
 		PROCEDURE  Decrypt* ( VAR buf: ARRAY OF CHAR; ofs, len: LONGINT );
-		VAR i, r: LONGINT;  X, Y: SET;  X0, Y0: SET;
+		VAR i, r: LONGINT;  X, Y: SET32;  X0, Y0: SET32;
 		BEGIN
 			ASSERT( isKeyInitialized );
 			ASSERT( len MOD blockSize = 0 );   (* padding must have been added *)
@@ -98,7 +98,7 @@ TYPE
 		END Decrypt;
 		
 				
-		PROCEDURE RoundE*( VAR x, y: SET );
+		PROCEDURE RoundE*( VAR x, y: SET32 );
 		VAR i: Ind4;
 		BEGIN
 			Split( ske[ki] / x, i );  INC( ki );
@@ -107,7 +107,7 @@ TYPE
 			y := y / sb7[i.a] / sb5[i.b] / sb3[i.c] / sb1[i.d]
 		END RoundE;
 		
-		PROCEDURE RoundD*( VAR x, y: SET );
+		PROCEDURE RoundD*( VAR x, y: SET32 );
 		VAR i: Ind4;
 		BEGIN
 			Split( skd[ki] / x, i );  INC( ki );
@@ -124,7 +124,7 @@ TYPE
 	
 	END Cipher;
 	
-	PROCEDURE -Split*( x: SET; VAR i4: Ind4 );
+	PROCEDURE -Split*( x: SET32; VAR i4: Ind4 );
 	BEGIN
 		i4.a := S.VAL( LONGINT, x ) MOD 40H;
 		i4.b := S.VAL( LONGINT, x ) DIV 100H MOD 40H;
@@ -141,8 +141,8 @@ TYPE
 	
 	
 			
-	PROCEDURE IP*( VAR x, y: SET );	(* initial permutation *)
-	VAR t: SET;
+	PROCEDURE IP*( VAR x, y: SET32 );	(* initial permutation *)
+	VAR t: SET32;
 	BEGIN
 		t := (LSH( x,   -4 ) / y) * Mask04;	 y := y / t;  x := x / LSH( t, 4 );
 		t := (LSH( x, -16 ) / y) * Mask16;	 y := y / t;  x := x / LSH( t, 16 );
@@ -153,8 +153,8 @@ TYPE
 		x := ROT( x, 1 );			
 	END IP;
 		
-	PROCEDURE FP*( VAR x, y: SET );	(* final permutation *)
-	VAR t: SET;
+	PROCEDURE FP*( VAR x, y: SET32 );	(* final permutation *)
+	VAR t: SET32;
 	BEGIN
 		x := ROT( x, -1 );
 		t := (x / y) * Mask01;  x := x / t;  y := y / t;
@@ -167,24 +167,24 @@ TYPE
 	
 	
 	
-	PROCEDURE ComputeSubkeys*( x, y: SET;  VAR sk: ARRAY OF SET; ofs: LONGINT );
-	VAR t: SET; i: LONGINT;
+	PROCEDURE ComputeSubkeys*( x, y: SET32;  VAR sk: ARRAY OF SET32; ofs: LONGINT );
+	VAR t: SET32; i: LONGINT;
 		
-		PROCEDURE sms( CONST LRHs: BitSwap;  x: SET; rs, ls: LONGINT ): SET;
+		PROCEDURE sms( CONST LRHs: BitSwap;  x: SET32; rs, ls: LONGINT ): SET32;
 		VAR i: LONGINT;
 		BEGIN
 			i := S.VAL( LONGINT, LSH( x, -rs ) ) MOD 16;
 			RETURN LSH( LRHs[i], ls ) 
 		END sms;
 			
-		PROCEDURE sm( b: SET; shift, mask: LONGINT ): SET;
+		PROCEDURE sm( b: SET32; shift, mask: LONGINT ): SET32;
 		BEGIN
-			RETURN LSH( b, shift ) * S.VAL( SET,  mask )
+			RETURN LSH( b, shift ) * S.VAL( SET32,  mask )
 		END sm;
 		
 	BEGIN
-		t := (LSH( y, -4 ) / x) * S.VAL( SET, 0F0F0F0FH );  x := x / t;  y := y / LSH( t, 4 );		
-		t := (y / x) * S.VAL( SET, 10101010H ); x := x / t;  y := y / t;
+		t := (LSH( y, -4 ) / x) * S.VAL( SET32, 0F0F0F0FH );  x := x / t;  y := y / LSH( t, 4 );		
+		t := (y / x) * S.VAL( SET32, 10101010H ); x := x / t;  y := y / t;
 			
 		x := 
 			sms( LHs, x, 0, 3 ) + sms( LHs, x, 8, 2 ) + sms( LHs, x, 16, 1 ) + sms( LHs, x, 24, 0 ) +
@@ -234,7 +234,7 @@ TYPE
 		buf: U.InitBuffer;
 		
 	
-		PROCEDURE InitTable( VAR tab: ARRAY OF SET );
+		PROCEDURE InitTable( VAR tab: ARRAY OF SET32 );
 		VAR i: LONGINT; 
 		BEGIN
 			FOR i := 0 TO LEN( tab ) - 1 DO  tab[i] := buf.GetSet( )  END

source/CryptoDES3.Mod

@@ -10,11 +10,11 @@ IMPORT Ciphers := CryptoCiphers, U := CryptoUtils, D := CryptoDES;
 TYPE
 	Cipher* = OBJECT (Ciphers.Cipher)
 			VAR 
-				ske, skd: ARRAY 96 OF SET; ski: LONGINT;
-				ivx, ivy: SET;
+				ske, skd: ARRAY 96 OF SET32; ski: LONGINT;
+				ivx, ivy: SET32;
 
 				PROCEDURE InitKey*( CONST src: ARRAY OF CHAR; keybits: LONGINT );
-				VAR X, Y: SET;  i: LONGINT;
+				VAR X, Y: SET32;  i: LONGINT;
 				BEGIN
 					ASSERT( keybits = 192 );
 					InitKey^( src, 64 );
@@ -47,7 +47,7 @@ TYPE
 				END SetIV;
 
 				PROCEDURE Encrypt*( VAR buf: ARRAY OF CHAR;  ofs, len: LONGINT );
-				VAR i, r: LONGINT;  X, Y: SET;
+				VAR i, r: LONGINT;  X, Y: SET32;
 				BEGIN
 					ASSERT( isKeyInitialized & (mode IN {Ciphers.ECB, Ciphers.CBC}) );
 					ASSERT( len MOD blockSize = 0 );   (* padding must have been added *)
@@ -76,7 +76,7 @@ TYPE
 				END Encrypt;
 
 				PROCEDURE Decrypt*( VAR buf: ARRAY OF CHAR;  ofs, len: LONGINT );
-				VAR i, r: LONGINT;  X, Y, X0, Y0: SET;
+				VAR i, r: LONGINT;  X, Y, X0, Y0: SET32;
 				BEGIN
 					ASSERT( isKeyInitialized );
 					ASSERT( len MOD blockSize = 0 );   (* padding must have been added *)
@@ -108,7 +108,7 @@ TYPE
 				END Decrypt;
 
 				
-				PROCEDURE RoundE*( VAR x, y: SET );
+				PROCEDURE RoundE*( VAR x, y: SET32 );
 				VAR i: D.Ind4;
 				BEGIN
 					D.Split( ske[ski] / x, i );  INC( ski );
@@ -117,7 +117,7 @@ TYPE
 					y := y / D.sb7[i.a] / D.sb5[i.b] / D.sb3[i.c] / D.sb1[i.d]
 				END RoundE;
 				
-				PROCEDURE RoundD*( VAR x, y: SET );
+				PROCEDURE RoundD*( VAR x, y: SET32 );
 				VAR i: D.Ind4;
 				BEGIN
 					D.Split( skd[ski] / x, i );  INC( ski );

source/CryptoDiffieHellman.Mod

@@ -7,7 +7,7 @@ TYPE
 			VAR
 				p, g: B.BigNumber;
 				priv: B.BigNumber;
-				initstate: SET;
+				initstate: SET32;
 
 				PROCEDURE & Init*( prkeybits: INTEGER;  CONST pname: ARRAY OF CHAR );
 				BEGIN

source/CryptoIDEA.Mod

@@ -114,7 +114,7 @@ TYPE
 
 	PROCEDURE shor( a, b: CARD16 ): CARD16;
 	BEGIN
-		RETURN S.VAL( LI, S.VAL( SET, LSH( a, 9 ) ) + S.VAL( SET, LSH( b, -7 ) ) ) MOD 10000H;
+		RETURN S.VAL( LI, S.VAL( SET32, LSH( a, 9 ) ) + S.VAL( SET32, LSH( b, -7 ) ) ) MOD 10000H;
 	END shor;
 
 	PROCEDURE CalcEncryptionKeys( CONST src: ARRAY OF CHAR;  VAR e: KeyBlock );
@@ -184,7 +184,7 @@ TYPE
 
 	PROCEDURE Xor( a, b: CARD16 ): CARD16;
 	BEGIN
-		RETURN S.VAL( LONGINT, S.VAL( SET, a )/S.VAL( SET, b ) )
+		RETURN S.VAL( LONGINT, S.VAL( SET32, a )/S.VAL( SET32, b ) )
 	END Xor;
 
 	PROCEDURE Mul( a, b: CARD16 ): CARD16;

source/CryptoKeccakF1600.Mod

@@ -15,7 +15,7 @@ CONST
 	nrRounds = 24;  nrLanes = 25;
 	
 TYPE
-	Lane = RECORD  low, high: SET  END;
+	Lane = RECORD  low, high: SET32  END;
 	State = ARRAY nrLanes OF Lane;
 
 VAR 
@@ -137,41 +137,41 @@ TYPE
 
 	(* Credit to Henry S. Warren, Hacker's Delight, Addison-Wesley, 2002	*)
 	PROCEDURE ToBitInterleaving( CONST in: Lane; VAR out: Lane );
-	VAR temp, temp0, temp1: SET;
+	VAR temp, temp0, temp1: SET32;
 	BEGIN
 	        temp0 := in.low;
 	        temp1 := in.high;
-	        temp := (temp0 / LSH( temp0, -1 )) * S.VAL( SET, 022222222H );  temp0 := temp0 / temp / LSH( temp, 1 );
-	        temp := (temp0 / LSH( temp0, -2 )) * S.VAL( SET, 00C0C0C0CH );  temp0 := temp0 / temp / LSH( temp, 2 );
-	        temp := (temp0 / LSH( temp0, -4 )) * S.VAL( SET, 000F000F0H );  temp0 := temp0 / temp / LSH( temp, 4 );
-	        temp := (temp0 / LSH( temp0, -8 )) * S.VAL( SET, 00000FF00H );  temp0 := temp0 / temp / LSH( temp, 8 );
+	        temp := (temp0 / LSH( temp0, -1 )) * S.VAL( SET32, 022222222H );  temp0 := temp0 / temp / LSH( temp, 1 );
+	        temp := (temp0 / LSH( temp0, -2 )) * S.VAL( SET32, 00C0C0C0CH );  temp0 := temp0 / temp / LSH( temp, 2 );
+	        temp := (temp0 / LSH( temp0, -4 )) * S.VAL( SET32, 000F000F0H );  temp0 := temp0 / temp / LSH( temp, 4 );
+	        temp := (temp0 / LSH( temp0, -8 )) * S.VAL( SET32, 00000FF00H );  temp0 := temp0 / temp / LSH( temp, 8 );
 	        
-	        temp := (temp1 / LSH( temp1, -1 )) * S.VAL( SET, 022222222H );  temp1 := temp1 / temp / LSH( temp, 1 );
-	        temp := (temp1 / LSH( temp1, -2 )) * S.VAL( SET, 00C0C0C0CH );  temp1 := temp1 / temp / LSH( temp, 2 );
-	        temp := (temp1 / LSH( temp1, -4 )) * S.VAL( SET, 000F000F0H );  temp1 := temp1 / temp / LSH( temp, 4 );
-	        temp := (temp1 / LSH( temp1, -8 )) * S.VAL( SET, 00000FF00H );  temp1 := temp1 / temp / LSH( temp, 8 );
-	        out.low := (temp0 * S.VAL( SET, 00000FFFFH )) + LSH( temp1, 16 );
-	        out.high := LSH( temp0, - 16) + (temp1 * S.VAL( SET, 0FFFF0000H ));
+	        temp := (temp1 / LSH( temp1, -1 )) * S.VAL( SET32, 022222222H );  temp1 := temp1 / temp / LSH( temp, 1 );
+	        temp := (temp1 / LSH( temp1, -2 )) * S.VAL( SET32, 00C0C0C0CH );  temp1 := temp1 / temp / LSH( temp, 2 );
+	        temp := (temp1 / LSH( temp1, -4 )) * S.VAL( SET32, 000F000F0H );  temp1 := temp1 / temp / LSH( temp, 4 );
+	        temp := (temp1 / LSH( temp1, -8 )) * S.VAL( SET32, 00000FF00H );  temp1 := temp1 / temp / LSH( temp, 8 );
+	        out.low := (temp0 * S.VAL( SET32, 00000FFFFH )) + LSH( temp1, 16 );
+	        out.high := LSH( temp0, - 16) + (temp1 * S.VAL( SET32, 0FFFF0000H ));
 	END ToBitInterleaving;
 
 	(* Credit to Henry S. Warren, Hacker's Delight, Addison-Wesley, 2002 *)
 	PROCEDURE FromBitInterleaving( CONST in: Lane;  VAR out: Lane );
-	VAR temp, temp0, temp1: SET;
+	VAR temp, temp0, temp1: SET32;
 	BEGIN
 	        temp0 := in.low; 
 	        temp1 := in.high; 
-	        temp := (temp0 * S.VAL( SET, 00000FFFFH )) + LSH( temp1, 16 ); 
-	        temp1 := LSH( temp0, - 16) + (temp1 * S.VAL( SET, 0FFFF0000H )); 
+	        temp := (temp0 * S.VAL( SET32, 00000FFFFH )) + LSH( temp1, 16 ); 
+	        temp1 := LSH( temp0, - 16) + (temp1 * S.VAL( SET32, 0FFFF0000H )); 
 	        temp0 := temp; 
-	        temp := (temp0 / LSH( temp0, -8 )) * S.VAL( SET, 00000FF00H );  temp0 := temp0 / temp / LSH( temp, 8 ); 
-	        temp := (temp0 / LSH( temp0, -4 )) * S.VAL( SET, 000F000F0H );  temp0 := temp0 / temp / LSH( temp, 4 ); 
-	        temp := (temp0 / LSH( temp0, -2 )) * S.VAL( SET, 00C0C0C0CH );  temp0 := temp0 / temp / LSH( temp, 2 ); 
-	        temp := (temp0 / LSH( temp0, -1 )) * S.VAL( SET, 022222222H );  temp0 := temp0 / temp / LSH( temp, 1 ); 
+	        temp := (temp0 / LSH( temp0, -8 )) * S.VAL( SET32, 00000FF00H );  temp0 := temp0 / temp / LSH( temp, 8 ); 
+	        temp := (temp0 / LSH( temp0, -4 )) * S.VAL( SET32, 000F000F0H );  temp0 := temp0 / temp / LSH( temp, 4 ); 
+	        temp := (temp0 / LSH( temp0, -2 )) * S.VAL( SET32, 00C0C0C0CH );  temp0 := temp0 / temp / LSH( temp, 2 ); 
+	        temp := (temp0 / LSH( temp0, -1 )) * S.VAL( SET32, 022222222H );  temp0 := temp0 / temp / LSH( temp, 1 ); 
 	        
-	        temp := (temp1 / LSH( temp1, -8 )) * S.VAL( SET, 00000FF00H );  temp1 := temp1 / temp / LSH( temp, 8 );
-	        temp := (temp1 / LSH( temp1, -4 )) * S.VAL( SET, 000F000F0H );  temp1 := temp1 / temp / LSH( temp, 4 );
-	        temp := (temp1 / LSH( temp1, -2 )) * S.VAL( SET, 00C0C0C0CH );  temp1 := temp1 / temp / LSH( temp, 2 );
-	        temp := (temp1 / LSH( temp1, -1 )) * S.VAL( SET, 022222222H );  temp1 := temp1 / temp / LSH( temp, 1 );
+	        temp := (temp1 / LSH( temp1, -8 )) * S.VAL( SET32, 00000FF00H );  temp1 := temp1 / temp / LSH( temp, 8 );
+	        temp := (temp1 / LSH( temp1, -4 )) * S.VAL( SET32, 000F000F0H );  temp1 := temp1 / temp / LSH( temp, 4 );
+	        temp := (temp1 / LSH( temp1, -2 )) * S.VAL( SET32, 00C0C0C0CH );  temp1 := temp1 / temp / LSH( temp, 2 );
+	        temp := (temp1 / LSH( temp1, -1 )) * S.VAL( SET32, 022222222H );  temp1 := temp1 / temp / LSH( temp, 1 );
 	        out.low := temp0;
 	        out.high := temp1;
 	END FromBitInterleaving;
@@ -179,7 +179,7 @@ TYPE
 
 
 	PROCEDURE ROL64( VAR lane: Lane; offset: LONGINT );
-	VAR tmp: SET;
+	VAR tmp: SET32;
 	BEGIN
 		IF ODD( offset ) THEN
 			tmp := lane.low;
@@ -264,7 +264,7 @@ TYPE
 
 	PROCEDURE InitializeRoundConstants;
 	VAR
-		LFSRstate: SET;
+		LFSRstate: SET32;
 		i, j, bit: LONGINT;
 		lane: Lane;
 	BEGIN
@@ -297,13 +297,13 @@ TYPE
 		END
 	END InitializeRhoOffsets;
 
-	PROCEDURE LFSR86540( VAR LFSR: SET ): BOOLEAN;
+	PROCEDURE LFSR86540( VAR LFSR: SET32 ): BOOLEAN;
 	VAR result: BOOLEAN;
 	BEGIN
 		result := 0 IN LFSR;
 		IF 7 IN LFSR THEN
 			(* Primitive polynomial over GF(2): x^8+x^6+x^5+x^4+1 *)
-			LFSR := LSH( LFSR, 1) / S.VAL( SET, 71H );
+			LFSR := LSH( LFSR, 1) / S.VAL( SET32, 71H );
 		ELSE
 			LFSR := LSH( LFSR, 1 )
 		END;

source/CryptoMD5.Mod

@@ -100,28 +100,28 @@ VAR
 		PROCEDURE -F1( VAR a: LONGINT;  b, c, d, x, s, t: LONGINT );
 		VAR f: LONGINT;
 		BEGIN
-			f := S.VAL( LONGINT, (S.VAL( SET, b ) * S.VAL( SET, c )) + ((-S.VAL( SET, b )) * S.VAL( SET, d )) );
+			f := S.VAL( LONGINT, (S.VAL( SET32, b ) * S.VAL( SET32, c )) + ((-S.VAL( SET32, b )) * S.VAL( SET32, d )) );
 			a := ROT( a + f + x + t, s ) + b
 		END F1;
 
 		PROCEDURE -F2( VAR a: LONGINT;  b, c, d, x, s, t: LONGINT );
 		VAR f: LONGINT;
 		BEGIN
-			f := S.VAL( LONGINT, (S.VAL( SET, b ) * S.VAL( SET, d )) + (S.VAL( SET, c ) * (-S.VAL( SET, d ))) );
+			f := S.VAL( LONGINT, (S.VAL( SET32, b ) * S.VAL( SET32, d )) + (S.VAL( SET32, c ) * (-S.VAL( SET32, d ))) );
 			a := ROT( a + f + x + t, s ) + b
 		END F2;
 
 		PROCEDURE -F3( VAR a: LONGINT;  b, c, d, x, s, t: LONGINT );
 		VAR f: LONGINT;
 		BEGIN
-			f := S.VAL( LONGINT, S.VAL( SET, b ) / S.VAL( SET, c ) / S.VAL( SET, d ) );
+			f := S.VAL( LONGINT, S.VAL( SET32, b ) / S.VAL( SET32, c ) / S.VAL( SET32, d ) );
 			a := ROT( a + f + x + t, s ) + b
 		END F3;
 
 		PROCEDURE -F4( VAR a: LONGINT;  b, c, d, x, s, t: LONGINT );
 		VAR f: LONGINT;
 		BEGIN
-			f := S.VAL( LONGINT, S.VAL( SET, c ) / (S.VAL( SET, b ) + (-S.VAL( SET, d ))) );
+			f := S.VAL( LONGINT, S.VAL( SET32, c ) / (S.VAL( SET32, b ) + (-S.VAL( SET32, d ))) );
 			a := ROT( a + f + x + t, s ) + b
 		END F4;
 	

source/CryptoPrimes.Mod

@@ -205,7 +205,7 @@ VAR
 	END witness;
 
 	PROCEDURE Init;
-	VAR sieve: ARRAY N OF SET; i, j, p, n: LONGINT;
+	VAR sieve: ARRAY N OF SET32; i, j, p, n: LONGINT;
 	BEGIN
 		(* compute the first N small primes *)
 		FOR i := 0 TO N - 1 DO sieve[i] := {0..31} END;

source/CryptoSHA1.Mod

@@ -106,56 +106,56 @@ TYPE
 
 (*	PROCEDURE F1( b, c, d: LONGINT ): LONGINT;
 	BEGIN
-		RETURN S.VAL( LONGINT, ((S.VAL( SET, c ) / S.VAL( SET, d )) * S.VAL( SET, b )) / S.VAL( SET, d ) )
+		RETURN S.VAL( LONGINT, ((S.VAL( SET32, c ) / S.VAL( SET32, d )) * S.VAL( SET32, b )) / S.VAL( SET32, d ) )
 	END F1;
 
 	PROCEDURE F2( b, c, d: LONGINT ): LONGINT;
 	BEGIN
-		RETURN S.VAL( LONGINT, S.VAL( SET, b ) / S.VAL( SET, c ) / S.VAL( SET, d ) )
+		RETURN S.VAL( LONGINT, S.VAL( SET32, b ) / S.VAL( SET32, c ) / S.VAL( SET32, d ) )
 	END F2;
 
 	PROCEDURE F3( b, c, d: LONGINT ): LONGINT;
 	BEGIN
-		RETURN S.VAL( LONGINT, (S.VAL( SET, b ) * S.VAL( SET, c )) + ((S.VAL( SET, b ) + S.VAL( SET, c )) * S.VAL( SET, d )) )
+		RETURN S.VAL( LONGINT, (S.VAL( SET32, b ) * S.VAL( SET32, c )) + ((S.VAL( SET32, b ) + S.VAL( SET32, c )) * S.VAL( SET32, d )) )
 	END F3;
 *)
 
-	PROCEDURE -tr0019( a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR  f: LONGINT; x: SET );
+	PROCEDURE -tr0019( a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR  f: LONGINT; x: SET32 );
 	BEGIN
 		f := S.VAL( LONGINT, x ) + e + 5A827999H + ROT( a, 5 ) + 
 			(*F1( b, c, d );*)
-			S.VAL( LONGINT, ((S.VAL( SET, c ) / S.VAL( SET, d )) * S.VAL( SET, b )) / S.VAL( SET, d ) );
+			S.VAL( LONGINT, ((S.VAL( SET32, c ) / S.VAL( SET32, d )) * S.VAL( SET32, b )) / S.VAL( SET32, d ) );
 		b := ROT( b, 30 );
 	END tr0019;
 
-	PROCEDURE -tr2039( a: LONGINT;  VAR b: LONGINT;  c, d, e: LONGINT;  VAR f: LONGINT;  x: SET );
+	PROCEDURE -tr2039( a: LONGINT;  VAR b: LONGINT;  c, d, e: LONGINT;  VAR f: LONGINT;  x: SET32 );
 	BEGIN
 		f := S.VAL( LONGINT, x ) + e + 6ED9EBA1H + ROT( a, 5 ) + 
 			(*F2( b, c, d );*)
-			S.VAL( LONGINT, S.VAL( SET, b ) / S.VAL( SET, c ) / S.VAL( SET, d ) );
+			S.VAL( LONGINT, S.VAL( SET32, b ) / S.VAL( SET32, c ) / S.VAL( SET32, d ) );
 		b := ROT( b, 30 );
 	END tr2039;
 
-	PROCEDURE -tr4059( a: LONGINT;  VAR b: LONGINT;  c, d, e: LONGINT;  VAR f: LONGINT;  x: SET);
+	PROCEDURE -tr4059( a: LONGINT;  VAR b: LONGINT;  c, d, e: LONGINT;  VAR f: LONGINT;  x: SET32);
 	BEGIN
 		f := S.VAL( LONGINT, x ) + e + LONGINT(8F1BBCDCH) + ROT( a, 5 ) + 
 			(*F3( b, c, d );*)
-			S.VAL( LONGINT, (S.VAL( SET, b ) * S.VAL( SET, c )) + ((S.VAL( SET, b ) + S.VAL( SET, c )) * S.VAL( SET, d )) );
+			S.VAL( LONGINT, (S.VAL( SET32, b ) * S.VAL( SET32, c )) + ((S.VAL( SET32, b ) + S.VAL( SET32, c )) * S.VAL( SET32, d )) );
 		b := ROT( b, 30 )
 	END tr4059;
 
-	PROCEDURE -tr6079( a: LONGINT;  VAR b: LONGINT;  c, d, e: LONGINT;  VAR f: LONGINT;  x: SET );
+	PROCEDURE -tr6079( a: LONGINT;  VAR b: LONGINT;  c, d, e: LONGINT;  VAR f: LONGINT;  x: SET32 );
 	BEGIN
 		f := S.VAL( LONGINT, x ) + e + LONGINT(0CA62C1D6H) + ROT( a, 5 ) + 
 			(*F2( b, c, d );*)
-			S.VAL( LONGINT, S.VAL( SET, b ) / S.VAL( SET, c ) / S.VAL( SET, d ) );
+			S.VAL( LONGINT, S.VAL( SET32, b ) / S.VAL( SET32, c ) / S.VAL( SET32, d ) );
 		b := ROT( b, 30 );
 	END tr6079;
 
 	PROCEDURE HashBlock( VAR state: State;  CONST buf: ARRAY OF CHAR;  pos: LONGINT );
 	VAR 
 		A, B, C, D, E, T: LONGINT;
-		x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xa, xb, xc, xd, xe, xf: SET;
+		x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xa, xb, xc, xd, xe, xf: SET32;
 	BEGIN
 		A := state[0];  B := state[1];  C := state[2];  D := state[3];  E := state[4];
 

source/CryptoSHA256.Mod

@@ -47,13 +47,13 @@ TYPE
 				IF i < 16 THEN
 					X[i] := U.IntFromBufferBE( buf, pos );  INC( pos, 4 )
 				ELSE
-					s0 := sigma0( S.VAL( SET, X[(i + 1) MOD 16] ) );
-					s1 := sigma1( S.VAL( SET, X[(i + 14) MOD 16] ) );
+					s0 := sigma0( S.VAL( SET32, X[(i + 1) MOD 16] ) );
+					s1 := sigma1( S.VAL( SET32, X[(i + 14) MOD 16] ) );
 					s := s0 + s1 + X[(i + 9) MOD 16];
 					INC( X[i MOD 16], s );  
 				END;
-				T1 := X[i MOD 16] + h + Sigma1Ch( S.VAL(SET, e), f, g) + K256[i];
-				T2 := Sigma0Maj( S.VAL(SET, a), b, c );
+				T1 := X[i MOD 16] + h + Sigma1Ch( S.VAL(SET32, e), f, g) + K256[i];
+				T2 := Sigma0Maj( S.VAL(SET32, a), b, c );
 				h := g;  g := f;  f := e;  e := d + T1;
 				d := c;  c := b;  b := a;  a := T1 + T2;
 			END;
@@ -129,29 +129,29 @@ TYPE
 
 
 
-	PROCEDURE Sigma0Maj( x: SET; y, z: LONGINT ): LONGINT;
+	PROCEDURE Sigma0Maj( x: SET32; y, z: LONGINT ): LONGINT;
 	VAR a, b: LONGINT; 
 	BEGIN 
 		a := S.VAL( LONGINT, ROT( x , 30 ) / ROT( x, 19 ) / ROT( x, 10 ) );
-		b := S.VAL( LONGINT, (x * S.VAL( SET, y )) / 
-							  (x * S.VAL( SET, z )) / (S.VAL( SET, y ) * S.VAL( SET, z )) );
+		b := S.VAL( LONGINT, (x * S.VAL( SET32, y )) / 
+							  (x * S.VAL( SET32, z )) / (S.VAL( SET32, y ) * S.VAL( SET32, z )) );
 		RETURN a + b
 	END Sigma0Maj;
 	
-	PROCEDURE Sigma1Ch( x: SET;  y, z: LONGINT ): LONGINT;
+	PROCEDURE Sigma1Ch( x: SET32;  y, z: LONGINT ): LONGINT;
 	VAR a, b: LONGINT; 
 	BEGIN 
 		a := S.VAL( LONGINT, ROT( x , 26 ) / ROT( x, 21 ) / ROT( x, 7 ) );
-		b := S.VAL( LONGINT, (x * S.VAL( SET, y )) / ((-x ) * S.VAL( SET, z )) );
+		b := S.VAL( LONGINT, (x * S.VAL( SET32, y )) / ((-x ) * S.VAL( SET32, z )) );
 		RETURN a + b
 	END Sigma1Ch;
 
-	PROCEDURE sigma0( x: SET ): LONGINT;
+	PROCEDURE sigma0( x: SET32 ): LONGINT;
 	BEGIN 
 		RETURN S.VAL( LONGINT, ROT( x , 25 ) / ROT( x, 14 ) / LSH( x, -3 ) )
 	END sigma0;
 	
-	PROCEDURE sigma1( x: SET ): LONGINT;
+	PROCEDURE sigma1( x: SET32 ): LONGINT;
 	BEGIN 
 		RETURN S.VAL( LONGINT, ROT( x , 15 ) / ROT( x, 13 ) / LSH( x, -10 ) )
 	END sigma1;

source/CryptoTwofish.Mod

@@ -10,12 +10,12 @@ CONST
 	N = 16;
 
 TYPE
-	Block = ARRAY 4 OF SET;
-	SKey = ARRAY 4 OF SET;
+	Block = ARRAY 4 OF SET32;
+	SKey = ARRAY 4 OF SET32;
 
 VAR
-	tab0: ARRAY 256 OF SET;
-	tab1: ARRAY 256 OF SET;
+	tab0: ARRAY 256 OF SET32;
+	tab1: ARRAY 256 OF SET32;
 
 TYPE
 	Cipher* = OBJECT (Ciphers.Cipher)
@@ -44,8 +44,8 @@ TYPE
 					nsub := 8 + N*2;
 					FOR i := 0 TO nsub DIV 2 - 1 DO
 						(* compute round subkeys for PHT *)
-						A := F32( S.VAL( SET, i*step ), k32e, keybits );  			 (* A uses even key dwords *)
-						B := ROT( F32( S.VAL( SET, i*step + bump ), k32o, keybits ), 8 );   (* B uses odd  key dwords *)
+						A := F32( S.VAL( SET32, i*step ), k32e, keybits );  			 (* A uses even key dwords *)
+						B := ROT( F32( S.VAL( SET32, i*step + bump ), k32o, keybits ), 8 );   (* B uses odd  key dwords *)
 						subkeys[i*2] := A + B;   							(* combine with a PHT *)
 						subkeys[i*2 + 1] := ROT( A + 2*B, 9 );
 					END
@@ -77,44 +77,44 @@ TYPE
 				END Decrypt;
 
 				PROCEDURE EncryptBlock( VAR buf: ARRAY OF CHAR;  pos: LONGINT );
-				VAR x: Block;  t0, t1, i, r: LONGINT;  s0, s1: SET;
+				VAR x: Block;  t0, t1, i, r: LONGINT;  s0, s1: SET32;
 				BEGIN
 					(* copy in the block, add whitening *)
 					FOR i := 0 TO 3 DO
-						x[i] := U.SetFromBufferLE( buf, pos + i*4 ) / S.VAL( SET, subkeys[i] );
+						x[i] := U.SetFromBufferLE( buf, pos + i*4 ) / S.VAL( SET32, subkeys[i] );
 						IF mode = Ciphers.CBC THEN  x[i] := x[i] / iv[i]  END
 					END;
 					(* main Twofish encryption loop *)
 					FOR r := 0 TO N - 1 DO
 						t0 := F32( x[0], sbox, keybits );
 						t1 := F32( ROT( x[1], 8 ), sbox, keybits );
-						x[2] := ROT( x[2] / S.VAL( SET, t0 + t1 + subkeys[8 + 2*r] ), -1 );
-						x[3] := ROT( x[3], 1 ) / S.VAL( SET, t0 + t1*2 + subkeys[8 + 2*r + 1] );
+						x[2] := ROT( x[2] / S.VAL( SET32, t0 + t1 + subkeys[8 + 2*r] ), -1 );
+						x[3] := ROT( x[3], 1 ) / S.VAL( SET32, t0 + t1*2 + subkeys[8 + 2*r + 1] );
 						IF r < N - 1 THEN  (* unswap, except for last round *)
 							s0 := x[0];  x[0] := x[2];  x[2] := s0;  s1 := x[1];  x[1] := x[3];  x[3] := s1;
 						END
 					END;
 					(* copy out, with whitening *)
 					FOR i := 0 TO 3 DO
-						x[i] := x[i] / S.VAL( SET, subkeys[4 + i] );  U.SetToBufferLE( x[i], buf, pos + i*4 );
+						x[i] := x[i] / S.VAL( SET32, subkeys[4 + i] );  U.SetToBufferLE( x[i], buf, pos + i*4 );
 						IF mode = Ciphers.CBC THEN  iv[i] := x[i]  END
 					END;
 				END EncryptBlock;
 
 				PROCEDURE DecryptBlock( VAR buf: ARRAY OF CHAR;  pos: LONGINT );
-				VAR x0, x: Block;  t0, t1, i, r: LONGINT;  s0, s1: SET;
+				VAR x0, x: Block;  t0, t1, i, r: LONGINT;  s0, s1: SET32;
 				BEGIN
 					(* copy in the block, add whitening *)
 					FOR i := 0 TO 3 DO  
 						x0[i] := U.SetFromBufferLE( buf, pos + i*4 );  
-						x[i] := x0[i] / S.VAL( SET, subkeys[4 + i] );   
+						x[i] := x0[i] / S.VAL( SET32, subkeys[4 + i] );   
 					END;
 					(* main Twofish decryption loop *)
 					FOR r := N - 1 TO 0 BY -1 DO
 						t0 := F32( x[0], sbox, keybits );
 						t1 := F32( ROT( x[1], 8 ), sbox, keybits );
-						x[2] := ROT( x[2], 1 );  x[2] := x[2] / S.VAL( SET, t0 + t1 + subkeys[8 + 2*r] );
-						x[3] := ROT( x[3] / S.VAL( SET, t0 + t1*2 + subkeys[8 + 2*r + 1] ), -1 );
+						x[2] := ROT( x[2], 1 );  x[2] := x[2] / S.VAL( SET32, t0 + t1 + subkeys[8 + 2*r] );
+						x[3] := ROT( x[3] / S.VAL( SET32, t0 + t1*2 + subkeys[8 + 2*r + 1] ), -1 );
 						IF r > 0 THEN  (* unswap, except for last round *)
 							s0 := x[0];  x[0] := x[2];  x[2] := s0;
 							s1 := x[1];  x[1] := x[3];  x[3] := s1;
@@ -122,7 +122,7 @@ TYPE
 					END;
 					(* copy out, with whitening *)
 					FOR i := 0 TO 3 DO
-						x[i] := x[i] / S.VAL( SET, subkeys[i] );
+						x[i] := x[i] / S.VAL( SET32, subkeys[i] );
 						IF mode = Ciphers.CBC THEN  x[i] := x[i] / iv[i];  iv[i] := x0[i]  END;
 						U.SetToBufferLE( x[i], buf, pos + i*4 );
 					END;
@@ -145,51 +145,51 @@ TYPE
 
 CONST
 	FDBK = 169H;
-	Fdbk2 = S.VAL( SET, FDBK DIV 2 );
-	Fdbk4 = S.VAL( SET, FDBK DIV 4 );
-	Byte0 = S.VAL( SET, 0FFH );
-	S14d = S.VAL( SET, 14DH );
-	S0a6 = S.VAL( SET, 0A6H );
+	Fdbk2 = S.VAL( SET32, FDBK DIV 2 );
+	Fdbk4 = S.VAL( SET32, FDBK DIV 4 );
+	Byte0 = S.VAL( SET32, 0FFH );
+	S14d = S.VAL( SET32, 14DH );
+	S0a6 = S.VAL( SET32, 0A6H );
 	
 	
-	PROCEDURE m1( x: LONGINT ): SET;
+	PROCEDURE m1( x: LONGINT ): SET32;
 	BEGIN
-		RETURN S.VAL( SET, x )
+		RETURN S.VAL( SET32, x )
 	END m1;
 
-	PROCEDURE mx( x: LONGINT ): SET;
-	VAR t: SET;
+	PROCEDURE mx( x: LONGINT ): SET32;
+	VAR t: SET32;
 	BEGIN
-		t := S.VAL( SET, x DIV 4 );
+		t := S.VAL( SET32, x DIV 4 );
 		IF ODD( x DIV 2 ) THEN  t := t / Fdbk2  END;
 		IF ODD( x ) THEN  t := t / Fdbk4  END;
-		RETURN S.VAL( SET, x ) / t
+		RETURN S.VAL( SET32, x ) / t
 	END mx;
 
-	PROCEDURE my( x: LONGINT ): SET;
-	VAR t1, t2: SET;
+	PROCEDURE my( x: LONGINT ): SET32;
+	VAR t1, t2: SET32;
 	BEGIN
-		t1 := S.VAL( SET, x DIV 2 );  t2 := S.VAL( SET, x DIV 4 );
+		t1 := S.VAL( SET32, x DIV 2 );  t2 := S.VAL( SET32, x DIV 4 );
 		IF ODD( x DIV 2 ) THEN  t2 := t2 / Fdbk2  END;
 		IF ODD( x ) THEN  t1 := t1 / Fdbk2;  t2 := t2 / Fdbk4  END;
-		RETURN S.VAL( SET, x ) / t1 / t2
+		RETURN S.VAL( SET32, x ) / t1 / t2
 	END my;
 
 	PROCEDURE split( x: LONGINT;  VAR v: SKey );
 	BEGIN
-		v[3] := S.VAL( SET, x DIV 1000000H MOD 100H );
-		v[2] := S.VAL( SET, x DIV 10000H MOD 100H );
-		v[1] := S.VAL( SET, x DIV 100H MOD 100H );
-		v[0] := S.VAL( SET, x MOD 100H );
+		v[3] := S.VAL( SET32, x DIV 1000000H MOD 100H );
+		v[2] := S.VAL( SET32, x DIV 10000H MOD 100H );
+		v[1] := S.VAL( SET32, x DIV 100H MOD 100H );
+		v[0] := S.VAL( SET32, x MOD 100H );
 	END split;
 	
-	PROCEDURE -Int( x: SET ): LONGINT;
+	PROCEDURE -Int( x: SET32 ): LONGINT;
 	BEGIN
 		RETURN S.VAL( LONGINT, x )
 	END Int;
 	
 
-	PROCEDURE F32( x: SET;  CONST k32: ARRAY OF LONGINT;  keybits: LONGINT ): LONGINT;
+	PROCEDURE F32( x: SET32;  CONST k32: ARRAY OF LONGINT;  keybits: LONGINT ): LONGINT;
 	VAR a, b, c, d, l: LONGINT;  k, k1: SKey;
 	BEGIN
 		(* Run each byte thru 8x8 S-boxes, xoring with key byte at each stage. *)
@@ -230,24 +230,24 @@ CONST
 
 	(* RS_MDS_Encode *)
 	PROCEDURE Encode( k0, k1: LONGINT ): LONGINT;
-	VAR i, j, b: LONGINT;  r, g2, g2s16, g3, g3s8, g3s24: SET;
+	VAR i, j, b: LONGINT;  r, g2, g2s16, g3, g3s8, g3s24: SET32;
 	BEGIN
-		r := S.VAL( SET, k1 );
+		r := S.VAL( SET32, k1 );
 		FOR i := 0 TO 1 DO
-			IF i # 0 THEN  r := r / S.VAL( SET, k0 )  END;
+			IF i # 0 THEN  r := r / S.VAL( SET32, k0 )  END;
 			FOR j := 0 TO 3 DO
 				b := S.VAL( LONGINT, LSH( r, -24 ) );
 
-				g2 := S.VAL( SET, b*2 );
+				g2 := S.VAL( SET32, b*2 );
 				IF b > 7FH THEN  g2 := (g2 / S14d) * Byte0  END;
 				g2s16 := LSH( g2, 16 );
 
-				g3 := S.VAL( SET, b DIV 2 ) / g2;
+				g3 := S.VAL( SET32, b DIV 2 ) / g2;
 				IF ODD( b ) THEN  g3 := g3 / S0a6  END;
 				g3s8 := LSH( g3, 8 );
 				g3s24 := LSH( g3s8, 16 );
 
-				r := LSH( r, 8 ) / g3s24 / g2s16 / g3s8 / S.VAL( SET, b ) 
+				r := LSH( r, 8 ) / g3s24 / g2s16 / g3s8 / S.VAL( SET32, b ) 
 			END
 		END;
 		RETURN S.VAL( LONGINT, r )

source/CryptoUtils.Mod

@@ -41,9 +41,9 @@ TYPE
 			RETURN x
 		END GetInt;
 		
-		PROCEDURE GetSet*(): SET;
+		PROCEDURE GetSet*(): SET32;
 		BEGIN
-			RETURN S.VAL( SET, GetInt() )
+			RETURN S.VAL( SET32, GetInt() )
 		END GetSet;
 		
 	END InitBuffer
@@ -248,7 +248,7 @@ VAR
 
 
 	PROCEDURE XORBlock*( VAR block, iv: ARRAY OF S.BYTE );
-	VAR a1, a2: ADDRESS; s1, s2: SET; i: LONGINT;
+	VAR a1, a2: ADDRESS; s1, s2: SET32; i: LONGINT;
 	BEGIN
 		a1 := ADDRESSOF( block );  a2 := ADDRESSOF( iv );
 		FOR i := 1 TO LEN( block ) DIV 4 DO
@@ -319,7 +319,7 @@ VAR
 		END
 	END BlockToBufferLE;
 	
-	PROCEDURE SetToBufferBE*( val: SET;  VAR buf: ARRAY OF CHAR;  pos: LONGINT );
+	PROCEDURE SetToBufferBE*( val: SET32;  VAR buf: ARRAY OF CHAR;  pos: LONGINT );
 	BEGIN
 		IntToBufferBE( S.VAL( LONGINT, val ), buf, pos );
 	END SetToBufferBE;
@@ -332,7 +332,7 @@ VAR
 		buf[pos + 0] := CHR( val MOD 256 );
 	END IntToBufferBE;
 	
-	PROCEDURE SetToBufferLE*( val: SET;  VAR buf: ARRAY OF CHAR;  pos: LONGINT );
+	PROCEDURE SetToBufferLE*( val: SET32;  VAR buf: ARRAY OF CHAR;  pos: LONGINT );
 	BEGIN
 		IntToBufferLE( S.VAL( LONGINT, val ), buf, pos );
 	END SetToBufferLE;
@@ -346,9 +346,9 @@ VAR
 	END IntToBufferLE;
 	
 	
-	PROCEDURE SetFromBufferBE*( CONST buf: ARRAY OF CHAR;  pos: LONGINT ): SET;
+	PROCEDURE SetFromBufferBE*( CONST buf: ARRAY OF CHAR;  pos: LONGINT ): SET32;
 	BEGIN
-		RETURN  S.VAL( SET, IntFromBufferBE( buf, pos ) )
+		RETURN  S.VAL( SET32, IntFromBufferBE( buf, pos ) )
 	END SetFromBufferBE;
 	
 	PROCEDURE IntFromBufferBE*( CONST buf: ARRAY OF CHAR;  pos: LONGINT ): LONGINT;
@@ -360,9 +360,9 @@ VAR
 	END IntFromBufferBE;
 
 
-	PROCEDURE SetFromBufferLE*( CONST buf: ARRAY OF CHAR;  pos: LONGINT ): SET;
+	PROCEDURE SetFromBufferLE*( CONST buf: ARRAY OF CHAR;  pos: LONGINT ): SET32;
 	BEGIN
-		RETURN  S.VAL( SET, IntFromBufferLE( buf, pos ) )
+		RETURN  S.VAL( SET32, IntFromBufferLE( buf, pos ) )
 	END SetFromBufferLE;
 
 	PROCEDURE IntFromBufferLE*( CONST buf: ARRAY OF CHAR;  pos: LONGINT ): LONGINT;