Changeset 161

Timestamp:

Apr 26, 2018, 1:10:38 PM (6 years ago)

Author:

chronos

Message:

• Modified: Further Int128 unit implementation.

Location:

branches/virtualcpu3

Files:

• UFormMain.lfm (modified) (1 diff)
• UFormMain.pas (modified) (3 diffs)
• UInt128.pas (modified) (22 diffs)

branches/virtualcpu3/UFormMain.lfm

@@ -7 +7 @@
   ClientHeight = 783
   ClientWidth = 1028
+  DesignTimePPI = 120
   OnShow = FormShow
-  LCLVersion = '1.8.0.4'
+  LCLVersion = '1.8.2.0'
   object Memo1: TMemo
     Left = 48

branches/virtualcpu3/UFormMain.pas

@@ -19 +19 @@
 
   public
-    procedure TestInt128;
   end;
 
@@ -54 +53 @@
   Writer64: TInstWriter64;
 begin
-  TestInt128;
-
 {  CPU8 := TCPU8.Create;
   Writer8 := TInstWriter8.Create;
@@ -93 +90 @@
 end;
 
-procedure TForm1.TestInt128;
-var
-  A, B, C: Int128;
-begin
-  A := 2;
-  B := 3;
-  C := A + B;
-  Memo1.Lines.Add(IntToStr(A) + ' + ' + IntToStr(B) + ' = ' + IntToStr(C));
-  C := A * B;
-  Memo1.Lines.Add(IntToStr(A) + ' * ' + IntToStr(B) + ' = ' + IntToStr(C));
-end;
-
 end.
 

branches/virtualcpu3/UInt128.pas

@@ -9 +9 @@
 
 type
+
+  { UInt128 }
+
+  UInt128 = packed record
+    procedure SetZero;
+    procedure SetOne;
+    procedure SetMinimum;
+    procedure SetMaximum;
+    function IsZero: Boolean;
+    function IsOne: Boolean;
+    function IsMinimum: Boolean;
+    function IsMaximum: Boolean;
+    class function Min(A, B: UInt128): UInt128; static;
+    class function Max(A, B: UInt128): UInt128; static;
+    class function Zero: UInt128; static;
+    class function One: UInt128; static;
+    class function Minimum: UInt128; static;
+    class function Maximum: UInt128; static;
+    class function Compare(A, B: UInt128): Int8; static;
+    class procedure IntDivMod(A, B: UInt128; var Q, R: UInt128); static;
+    class operator Inc(A: UInt128): UInt128;
+    class operator Dec(A: UInt128): UInt128;
+    class operator Implicit(A: ShortInt): UInt128;
+    class operator Implicit(A: Byte): UInt128;
+    class operator Implicit(A: UInt128): Byte;
+    class operator Implicit(A: UInt128): LongWord;
+    class operator Implicit(A: UInt128): ShortInt;
+    class operator BitwiseXor(A, B: UInt128): UInt128;
+    class operator BitwiseAnd(A, B: UInt128): UInt128;
+    class operator BitwiseOr(A, B: UInt128): UInt128;
+    class operator Add(A, B: UInt128): UInt128;
+    class operator Subtract(A, B: UInt128): UInt128;
+    class operator Equal(A, B: UInt128): Boolean;
+    class operator LessThan(A, B: UInt128): Boolean;
+    class operator LessThanOrEqual(A, B: UInt128): Boolean;
+    class operator GreaterThan(A, B: UInt128): Boolean;
+    class operator GreaterThanOrEqual(A, B: UInt128): Boolean;
+    class operator Multiply(A, B: UInt128): UInt128;
+    class operator IntDivide(A, B: UInt128): UInt128;
+    class operator Modulus(A, B: UInt128): UInt128;
+    class operator LeftShift(A, B: UInt128): UInt128;
+    class operator RightShift(A, B: UInt128): UInt128;
+    case Integer of
+      0: (Bytes: array[0..15] of Byte);
+      1: (Words: array[0..7] of Word);
+      2: (LongWords: array[0..3] of LongWord);
+      3: (QWords: array[0..1] of QWord);
+  end;
+  PUInt128 = ^UInt128;
 
   { Int128 }
@@ -27 +76 @@
     function Abs: Int128;
     function Sign: Int8;
-    function Min(A, B: Int128): Int128;
-    function Max(A, B: Int128): Int128;
+    class function Min(A, B: Int128): Int128; static;
+    class function Max(A, B: Int128): Int128; static;
     class function Zero: Int128; static;
     class function One: Int128; static;
@@ -35 +84 @@
     class function Maximum: Int128; static;
     class function Compare(A, B: Int128): Int8; static;
+    class procedure IntDivMod(A, B: Int128; var Q, R: Int128); static;
+    class operator Inc(A: Int128): Int128;
+    class operator Dec(A: Int128): Int128;
     class operator Implicit(A: ShortInt): Int128;
     class operator Implicit(A: Byte): Int128;
+    class operator Implicit(A: Int64): Int128;
+    class operator Implicit(A: UInt128): Int128;
+    class operator Implicit(A: Int128): ShortInt;
     class operator Implicit(A: Int128): Byte;
     class operator Implicit(A: Int128): LongWord;
+    class operator Implicit(A: Int128): UInt128;
     class operator BitwiseXor(A, B: Int128): Int128;
     class operator BitwiseAnd(A, B: Int128): Int128;
@@ -67 +123 @@
   PInt128 = ^Int128;
 
-function IntToStr(Value: Int128): string;
+function IntToStr(Value: Int128): string; overload;
+function IntToStr(Value: UInt128): string; overload;
+function IntToHex(Value: Int128; Digits: integer): string; overload;
+function IntToHex(Value: UInt128; Digits: integer): string; overload;
 
 
 implementation
+
+
+const
+   HexDigits: array[0..15] of Char = '0123456789ABCDEF';
 
 // Raise errors using Error function in System.pas
@@ -78 +141 @@
   Error(reIntOverflow);
 end;
+{$ENDIF}
+
+{$IFOPT R+}
+procedure RaiseRangeError;
+begin
+  Error(reRangeError);
+end;
+{$ENDIF}
+procedure RaiseDivByZeroError;
+begin
+  Error(reDivByZero);
+end;
+
+function IntToHex(Value: Int128; Digits: integer): string;
+var
+  I: Integer;
+begin
+  if Digits = 0 then
+    Digits := 1;
+  SetLength(Result, Digits);
+  for I := 0 to Digits - 1 do
+  begin
+    Result[Digits - I] := HexDigits[Value and 15];
+    Value := Value shr 4;
+  end ;
+  while Value <> 0 do begin
+    Result := HexDigits[Value and 15] + Result;
+    Value := Value shr 4;
+  end;
+end;
+
+function IntToHex(Value: UInt128; Digits: integer): string;
+var
+  I: Integer;
+begin
+  if Digits = 0 then
+    Digits := 1;
+  SetLength(Result, Digits);
+  for I := 0 to Digits - 1 do
+  begin
+    Result[Digits - I] := HexDigits[Value and 15];
+    Value := Value shr 4;
+  end ;
+  while Value <> 0 do begin
+    Result := HexDigits[Value and 15] + Result;
+    Value := Value shr 4;
+  end;
+end;
 
 function IntToStr(Value: Int128): string;
@@ -83 +194 @@
   Result := '';
   if Value < 0 then begin
-    while Value < 9 do begin
+    Value := -Value;
+    while Value > 9 do begin
       Result := Chr(Ord('0') + (Value mod 10)) + Result;
       Value := Value div 10;
@@ -90 +202 @@
   end else begin
     while Value > 9 do begin
-      Result := Result + Chr(Ord('0') + (Value mod 10));
+      Result := Chr(Ord('0') + (Value mod 10)) + Result;
       Value := Value div 10;
     end;
@@ -97 +209 @@
 end;
 
-{$ENDIF}
-
-{ Int128 }
-
-procedure Int128.SetZero;
+function IntToStr(Value: UInt128): string;
+begin
+  Result := '';
+  while Value < 9 do begin
+    Result := Chr(Ord('0') + (Value mod 10)) + Result;
+    Value := Value div 10;
+  end;
+  Result := Chr(Ord('0') + (Value mod 10)) + Result;
+end;
+
+{ UInt128 }
+
+procedure UInt128.SetZero;
 begin
   QWords[0] := 0;
@@ -107 +227 @@
 end;
 
-procedure Int128.SetOne;
+procedure UInt128.SetOne;
 begin
   QWords[0] := 1;
@@ -113 +233 @@
 end;
 
-procedure Int128.SetMinusOne;
+procedure UInt128.SetMinimum;
+begin
+  SetZero;
+end;
+
+procedure UInt128.SetMaximum;
 begin
   LongWords[0] := $ffffffff;
@@ -121 +246 @@
 end;
 
+function UInt128.IsZero: Boolean;
+begin
+  Result := Self = UInt128.Zero;
+end;
+
+function UInt128.IsOne: Boolean;
+begin
+  Result := Self = UInt128.One;
+end;
+
+function UInt128.IsMinimum: Boolean;
+begin
+  Result := Self = UInt128.Minimum;
+end;
+
+function UInt128.IsMaximum: Boolean;
+begin
+  Result := Self = UInt128.Maximum;
+end;
+
+class function UInt128.Min(A, B: UInt128): UInt128;
+begin
+  if A < B then Result := A else Result := B;
+end;
+
+class function UInt128.Max(A, B: UInt128): UInt128;
+begin
+  if A > B then Result := A else Result := B;
+end;
+
+class function UInt128.Zero: UInt128;
+begin
+  Result.SetZero;
+end;
+
+class function UInt128.One: UInt128;
+begin
+  Result.SetOne;
+end;
+
+class function UInt128.Minimum: UInt128;
+begin
+  Result.SetMinimum;
+end;
+
+class function UInt128.Maximum: UInt128;
+begin
+  Result.SetMaximum;
+end;
+
+class function UInt128.Compare(A, B: UInt128): Int8;
+var
+  C, D: LongWord;
+begin
+  C := A.LongWords[3];
+  D := B.LongWords[3];
+  if C = D then
+    begin
+      C := A.LongWords[2];
+      D := B.LongWords[2];
+      if C = D then
+        begin
+          C := A.LongWords[1];
+          D := B.LongWords[1];
+          if C = D then
+            begin
+              C := A.LongWords[0];
+              D := B.LongWords[0];
+            end;
+        end;
+    end;
+  if C > D then
+    Result := 1 else
+  if C < D then
+    Result := -1
+  else
+    Result := 0;
+end;
+
+class operator UInt128.Implicit(A: ShortInt): UInt128;
+begin
+  {$IFOPT R+}
+  if A < 0 then
+    RaiseRangeError;
+  {$ENDIF}
+  Result.SetZero;
+  Result.Bytes[0] := A;
+end;
+
+class operator UInt128.Implicit(A: Byte): UInt128;
+begin
+  Result.SetZero;
+  Result.Bytes[0] := A;
+end;
+
+class operator UInt128.Implicit(A: UInt128): Byte;
+begin
+  Result := A.Bytes[0];
+end;
+
+class operator UInt128.Implicit(A: UInt128): LongWord;
+begin
+  Result := A.LongWords[0];
+end;
+
+class operator UInt128.Implicit(A: UInt128): ShortInt;
+begin
+  {$IFOPT R+}
+  if not (A <= High(ShortInt)) then
+    RaiseRangeError;
+  {$ENDIF}
+  Result := A.Bytes[0];
+end;
+
+class operator UInt128.BitwiseXor(A, B: UInt128): UInt128;
+begin
+  Result.LongWords[0] := A.LongWords[0] xor B.LongWords[0];
+  Result.LongWords[1] := A.LongWords[1] xor B.LongWords[1];
+end;
+
+class operator UInt128.BitwiseAnd(A, B: UInt128): UInt128;
+begin
+  Result.LongWords[0] := A.LongWords[0] and B.LongWords[0];
+  Result.LongWords[1] := A.LongWords[1] and B.LongWords[1];
+end;
+
+class operator UInt128.BitwiseOr(A, B: UInt128): UInt128;
+begin
+  Result.LongWords[0] := A.LongWords[0] or B.LongWords[0];
+  Result.LongWords[1] := A.LongWords[1] or B.LongWords[1];
+end;
+
+class operator UInt128.Add(A, B: UInt128): UInt128;
+var
+  C: LongWord;
+  D: Integer;
+begin
+  C := LongWord(A.Words[0]) + B.Words[0];
+  Result.Words[0] := Word(C and $FFFF);
+
+  for D := 1 to 7 do begin
+    C := C shr 16;
+    Inc(C, A.Words[D]);
+    Inc(C, B.Words[D]);
+    Result.Words[D] := Word(C and $FFFF);
+  end;
+
+  {$IFOPT Q+}
+  C := C shr 16;
+  if C > 0 then RaiseOverflowError;
+  {$ENDIF}
+end;
+
+class operator UInt128.Subtract(A, B: UInt128): UInt128;
+var
+  C, D: Integer;
+begin
+  C := A.Words[0];
+  Dec(C, B.Words[0]);
+  Result.Words[0] := Word(C);
+
+  for D := 1 to 7 do
+    begin
+      if C < 0 then C := -1 else C := 0;
+      Inc(C, A.Words[D]);
+      Dec(C, B.Words[D]);
+      Result.Words[D] := Word(C);
+    end;
+
+  {$IFOPT Q+}
+  if C < 0 then RaiseOverflowError;
+  {$ENDIF}
+end;
+
+class operator UInt128.Equal(A, B: UInt128): Boolean;
+begin
+  Result := (A.LongWords[0] = B.LongWords[0]) and
+    (A.LongWords[1] = B.LongWords[1]);
+end;
+
+class operator UInt128.LessThan(A, B: UInt128): Boolean;
+var
+  G: Int8;
+begin
+  G := Compare(A, B);
+  Result := G = -1;
+end;
+
+class operator UInt128.LessThanOrEqual(A, B: UInt128): Boolean;
+begin
+  Result := not (A > B);
+end;
+
+class operator UInt128.GreaterThan(A, B: UInt128): Boolean;
+begin
+  Result := Compare(A, B) = 1;
+end;
+
+class operator UInt128.GreaterThanOrEqual(A, B: UInt128): Boolean;
+begin
+  Result := not (A < B);
+end;
+
+class operator UInt128.Multiply(A, B: UInt128): UInt128;
+var
+  C : Int64;
+begin
+  C := LongWord(A.Words[0]) * B.Words[0];
+  Result.Words[0] := Word(C);
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[0]) * B.Words[1]);
+  Inc(C, LongWord(A.Words[1]) * B.Words[0]);
+  Result.Words[1] := Word(C);
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[0]) * B.Words[2]);
+  Inc(C, LongWord(A.Words[1]) * B.Words[1]);
+  Inc(C, LongWord(A.Words[2]) * B.Words[0]);
+  Result.Words[2] := Word(C);
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[0]) * B.Words[3]);
+  Inc(C, LongWord(A.Words[1]) * B.Words[2]);
+  Inc(C, LongWord(A.Words[2]) * B.Words[1]);
+  Inc(C, LongWord(A.Words[3]) * B.Words[0]);
+  Result.Words[3] := Word(C);
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[0]) * B.Words[4]);
+  Inc(C, LongWord(A.Words[1]) * B.Words[3]);
+  Inc(C, LongWord(A.Words[2]) * B.Words[2]);
+  Inc(C, LongWord(A.Words[3]) * B.Words[1]);
+  Inc(C, LongWord(A.Words[4]) * B.Words[0]);
+  Result.Words[4] := Word(C);
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[0]) * B.Words[5]);
+  Inc(C, LongWord(A.Words[1]) * B.Words[4]);
+  Inc(C, LongWord(A.Words[2]) * B.Words[3]);
+  Inc(C, LongWord(A.Words[3]) * B.Words[2]);
+  Inc(C, LongWord(A.Words[4]) * B.Words[1]);
+  Inc(C, LongWord(A.Words[5]) * B.Words[0]);
+  Result.Words[5] := Word(C);
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[0]) * B.Words[6]);
+  Inc(C, LongWord(A.Words[1]) * B.Words[5]);
+  Inc(C, LongWord(A.Words[2]) * B.Words[4]);
+  Inc(C, LongWord(A.Words[3]) * B.Words[3]);
+  Inc(C, LongWord(A.Words[4]) * B.Words[2]);
+  Inc(C, LongWord(A.Words[5]) * B.Words[1]);
+  Inc(C, LongWord(A.Words[6]) * B.Words[0]);
+  Result.Words[6] := Word(C);
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[0]) * B.Words[7]);
+  Inc(C, LongWord(A.Words[1]) * B.Words[6]);
+  Inc(C, LongWord(A.Words[2]) * B.Words[5]);
+  Inc(C, LongWord(A.Words[3]) * B.Words[4]);
+  Inc(C, LongWord(A.Words[4]) * B.Words[3]);
+  Inc(C, LongWord(A.Words[5]) * B.Words[2]);
+  Inc(C, LongWord(A.Words[6]) * B.Words[1]);
+  Inc(C, LongWord(A.Words[7]) * B.Words[0]);
+  Result.Words[7] := Word(C);
+
+  {$IFOPT Q+}
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[1]) * B.Words[7]);
+  Inc(C, LongWord(A.Words[2]) * B.Words[6]);
+  Inc(C, LongWord(A.Words[3]) * B.Words[5]);
+  Inc(C, LongWord(A.Words[4]) * B.Words[4]);
+  Inc(C, LongWord(A.Words[5]) * B.Words[3]);
+  Inc(C, LongWord(A.Words[6]) * B.Words[2]);
+  Inc(C, LongWord(A.Words[7]) * B.Words[1]);
+  if C > 0 then
+    RaiseOverflowError;
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[2]) * B.Words[7]);
+  Inc(C, LongWord(A.Words[3]) * B.Words[6]);
+  Inc(C, LongWord(A.Words[4]) * B.Words[5]);
+  Inc(C, LongWord(A.Words[5]) * B.Words[4]);
+  Inc(C, LongWord(A.Words[6]) * B.Words[3]);
+  Inc(C, LongWord(A.Words[7]) * B.Words[2]);
+  if C > 0 then
+    RaiseOverflowError;
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[3]) * B.Words[7]);
+  Inc(C, LongWord(A.Words[4]) * B.Words[6]);
+  Inc(C, LongWord(A.Words[5]) * B.Words[5]);
+  Inc(C, LongWord(A.Words[6]) * B.Words[4]);
+  Inc(C, LongWord(A.Words[7]) * B.Words[3]);
+  if C > 0 then
+    RaiseOverflowError;
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[4]) * B.Words[7]);
+  Inc(C, LongWord(A.Words[5]) * B.Words[6]);
+  Inc(C, LongWord(A.Words[6]) * B.Words[5]);
+  Inc(C, LongWord(A.Words[7]) * B.Words[4]);
+  if C > 0 then
+    RaiseOverflowError;
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[5]) * B.Words[7]);
+  Inc(C, LongWord(A.Words[6]) * B.Words[6]);
+  Inc(C, LongWord(A.Words[7]) * B.Words[5]);
+  if C > 0 then
+    RaiseOverflowError;
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[6]) * B.Words[7]);
+  Inc(C, LongWord(A.Words[7]) * B.Words[6]);
+  if C > 0 then
+    RaiseOverflowError;
+
+  C := C shr 16;
+  Inc(C, LongWord(A.Words[7]) * B.Words[7]);
+  if C > 0 then
+    RaiseOverflowError;
+  {$ENDIF}
+end;
+
+class operator UInt128.IntDivide(A, B: UInt128): UInt128;
+var
+  M: UInt128;
+begin
+  IntDivMod(A, B, Result, M);
+end;
+
+class procedure UInt128.IntDivMod(A, B: UInt128; var Q, R: UInt128);
+var
+  C: Integer;
+  D: UInt128;
+begin
+  // Handle special cases
+  if B.IsZero then begin // B = 0
+    RaiseDivByZeroError;
+  end else
+  if B.IsOne then begin// B = 1
+    Q := A;
+    R.SetZero;
+    Exit;
+  end else
+  if A.IsZero then begin // A = 0
+    Q.SetZero;
+    R.SetZero;
+    Exit;
+  end;
+  C := UInt128.Compare(A, B);
+  if C < 0 then begin // A < B
+    R := A;
+    Q.SetZero;
+    Exit;
+  end else
+  if C = 0 then begin // A = B
+    Q.SetOne;
+    R.SetZero;
+    Exit;
+  end;
+  // Divide using "restoring radix two" division
+  D := A;
+  R.SetZero; // remainder (128 bits)
+  Q.SetZero; // quotient (128 bits)
+  for C := 0 to 127 do begin
+    // Shift high bit of dividend D into low bit of remainder R
+    R := R shl 1;
+    if D.LongWords[3] and $80000000 <> 0 then
+      R.LongWords[0] := R.LongWords[0] or 1;
+    D := D shl 1;
+    // Shift quotient
+    Q := Q shl 1;
+    // Subtract divisor from remainder if large enough
+    if UInt128.Compare(R, B) >= 0 then begin
+      R := R - B;
+      // Set result bit in quotient
+      Q.LongWords[0] := Q.LongWords[0] or 1;
+    end;
+  end;
+end;
+
+class operator UInt128.Inc(A: UInt128): UInt128;
+var
+  C: LongWord;
+  D: Integer;
+begin
+  C := A.Words[0];
+  Inc(C);
+  Result.Words[0] := Word(C and $FFFF);
+
+  C := C shr 16;
+  if C = 0 then Exit;
+  Inc(C, A.Words[1]);
+  Result.Words[1] := Word(C and $FFFF);
+
+  for D := 2 to 7 do begin
+    C := C shr 16;
+    if C = 0 then Exit;
+    Inc(C, A.Words[D]);
+    Result.Words[D] := Word(C and $FFFF);
+  end;
+
+  {$IFOPT Q+}
+  C := C shr 16;
+  if C > 0 then RaiseOverflowError;
+  {$ENDIF}
+end;
+
+class operator UInt128.Dec(A: UInt128): UInt128;
+begin
+  Result := A - 1;
+end;
+
+class operator UInt128.Modulus(A, B: UInt128): UInt128;
+var
+  D: UInt128;
+begin
+  IntDivMod(A, B, D, Result);
+end;
+
+class operator UInt128.LeftShift(A, B: UInt128): UInt128;
+var
+  C, D : Byte;
+begin
+  if B = 0 then begin
+    Exit;
+  end else
+  if B = 1 then begin
+    Result.LongWords[3] := (A.LongWords[3] shl 1) or (A.LongWords[2] shr 31);
+    Result.LongWords[2] := (A.LongWords[2] shl 1) or (A.LongWords[1] shr 31);
+    Result.LongWords[1] := (A.LongWords[1] shl 1) or (A.LongWords[0] shr 31);
+    Result.LongWords[0] := (A.LongWords[0] shl 1);
+  end else
+  if B >= 128 then begin
+    A.SetZero;
+  end else
+  if B < 32 then begin // 1 <= B <= 31
+    C := 32 - B;
+    Result.LongWords[3] := (A.LongWords[3] shl B) or (A.LongWords[2] shr C);
+    Result.LongWords[2] := (A.LongWords[2] shl B) or (A.LongWords[1] shr C);
+    Result.LongWords[1] := (A.LongWords[1] shl B) or (A.LongWords[0] shr C);
+    Result.LongWords[0] := (A.LongWords[0] shl B);
+  end else
+  if B < 64 then begin // 32 <= B <= 63
+    D := B - 32;
+    C := 32 - D;
+    Result.LongWords[3] := (A.LongWords[2] shl D) or (A.LongWords[1] shr C);
+    Result.LongWords[2] := (A.LongWords[1] shl D) or (A.LongWords[0] shr C);
+    Result.LongWords[1] := (A.LongWords[0] shl D);
+    Result.LongWords[0] := 0;
+  end else
+  if B < 96 then begin // 64 <= B <= 95
+    D := B - 64;
+    C := 32 - D;
+    Result.LongWords[3] := (A.LongWords[1] shl D) or (A.LongWords[0] shr C);
+    Result.LongWords[2] := (A.LongWords[0] shl D);
+    Result.LongWords[1] := 0;
+    Result.LongWords[0] := 0;
+  end else begin          // 96 <= B <= 127
+    D := B - 96;
+    Result.LongWords[3] := (A.LongWords[0] shl D);
+    Result.LongWords[2] := 0;
+    Result.LongWords[1] := 0;
+    Result.LongWords[0] := 0;
+  end;
+end;
+
+class operator UInt128.RightShift(A, B: UInt128): UInt128;
+var
+  C, D : Byte;
+begin
+  if B = 0 then begin
+    Exit;
+  end else
+  if B = 1 then begin
+    Result.LongWords[0] := (A.LongWords[0] shr 1) or (A.LongWords[1] shl 31);
+    Result.LongWords[1] := (A.LongWords[1] shr 1) or (A.LongWords[2] shl 31);
+    Result.LongWords[2] := (A.LongWords[2] shr 1) or (A.LongWords[3] shl 31);
+    Result.LongWords[3] := (A.LongWords[3] shr 1);
+  end else
+  if B >= 128 then begin
+    A.SetZero;
+  end else
+  if B < 32 then begin // 1 <= B <= 31
+    C := 32 - B;
+    Result.LongWords[0] := (A.LongWords[0] shr B) or (A.LongWords[1] shl C);
+    Result.LongWords[1] := (A.LongWords[1] shr B) or (A.LongWords[2] shl C);
+    Result.LongWords[2] := (A.LongWords[2] shr B) or (A.LongWords[3] shl C);
+    Result.LongWords[3] := (A.LongWords[3] shr B);
+  end else
+  if B < 64 then begin // 32 <= B <= 63
+    D := B - 32;
+    C := 32 - D;
+    Result.LongWords[0] := (A.LongWords[1] shr D) or (A.LongWords[2] shl C);
+    Result.LongWords[1] := (A.LongWords[2] shr D) or (A.LongWords[3] shl C);
+    Result.LongWords[2] := (A.LongWords[3] shr D);
+    Result.LongWords[3] := 0;
+  end else
+  if B < 96 then begin // 64 <= B <= 95
+    D := B - 64;
+    C := 32 - D;
+    Result.LongWords[0] := (A.LongWords[2] shr D) or (A.LongWords[3] shl C);
+    Result.LongWords[1] := (A.LongWords[3] shr D);
+    Result.LongWords[2] := 0;
+    Result.LongWords[3] := 0;
+  end else begin           // 96 <= B <= 127
+    D := B - 96;
+    Result.LongWords[0] := (A.LongWords[3] shr D);
+    Result.LongWords[1] := 0;
+    Result.LongWords[2] := 0;
+    Result.LongWords[3] := 0;
+  end;
+end;
+
+{ Int128 }
+
+procedure Int128.SetZero;
+begin
+  QWords[0] := 0;
+  QWords[1] := 0;
+end;
+
+procedure Int128.SetOne;
+begin
+  QWords[0] := 1;
+  QWords[1] := 0;
+end;
+
+procedure Int128.SetMinusOne;
+begin
+  LongWords[0] := $ffffffff;
+  LongWords[1] := $ffffffff;
+  LongWords[2] := $ffffffff;
+  LongWords[3] := $ffffffff;
+end;
+
 procedure Int128.SetMinimum;
 begin
@@ -137 +800 @@
 function Int128.IsNegative: Boolean;
 begin
-  Result := Sign = -1;
+  Result := (LongWords[3] and $80000000) <> 0;
 end;
 
 function Int128.IsPositive: Boolean;
 begin
-  Result := Sign <> -1;
+  Result := (LongWords[3] and $80000000) = 0;
 end;
 
@@ -208 +871 @@
 end;
 
-function Int128.Min(A, B: Int128): Int128;
+class function Int128.Min(A, B: Int128): Int128;
 begin
   if A < B then Result := A else Result := B;
 end;
 
-function Int128.Max(A, B: Int128): Int128;
+class function Int128.Max(A, B: Int128): Int128;
 begin
   if A > B then Result := A else Result := B;
@@ -222 +885 @@
   if A < 0 then begin
     Result.SetMinusOne;
-    Result.Bytes[0] := A;
+    Result.ShortInts[0] := A;
   end else begin
     Result.SetZero;
-    Result.Bytes[0] := A;
+    Result.ShortInts[0] := A;
   end;
 end;
@@ -235 +898 @@
 end;
 
+class operator Int128.Implicit(A: Int64): Int128;
+begin
+  Result.Int64s[0] := A;
+  if A < 0 then Result.Int64s[1] := -1
+    else Result.Int64s[1] := 0;
+end;
+
 class operator Int128.Implicit(A: Int128): Byte;
 begin
+  {$IFOPT R+}
+  if not ((A <= High(Byte)) and (A >= Low(Byte))) then
+    RaiseRangeError;
+  {$ENDIF}
   Result := A.Bytes[0];
 end;
@@ -243 +917 @@
 begin
   Result := A.LongWords[0];
+end;
+
+class operator Int128.Implicit(A: Int128): UInt128;
+begin
+  {$IFOPT R+}
+  if A.IsNegative then
+    RaiseRangeError;
+  {$ENDIF}
+  Result.QWords[0] := A.QWords[0];
+  Result.QWords[1] := A.QWords[1];
+end;
+
+class operator Int128.Implicit(A: UInt128): Int128;
+begin
+  {$IFOPT R+}
+  if A.LongWords[3] and $80000000 <> 0 then
+    RaiseRangeError;
+  {$ENDIF}
+  Result.LongWords[0] := A.LongWords[0];
+  Result.LongWords[1] := A.LongWords[1];
+  Result.LongWords[2] := A.LongWords[2];
+  Result.LongWords[3] := A.LongWords[3];
+end;
+
+class operator Int128.Implicit(A: Int128): ShortInt;
+begin
+  {$IFOPT R+}
+  if not ((A <= High(ShortInt)) and (A >= Low(ShortInt))) then
+    RaiseRangeError;
+  {$ENDIF}
+  Result := A.ShortInts[0];
 end;
 
@@ -295 +1000 @@
 end;
 
+class procedure Int128.IntDivMod(A, B: Int128; var Q, R: Int128);
+var
+  C, T: UInt128;
+  D, E: UInt128;
+begin
+  C := A.Abs;
+  D := B.Abs;
+  UInt128.IntDivMod(C, D, T, E);
+  if not (A.IsNegative xor B.IsNegative) then Q := T
+    else Q := -Int128(T);
+  R := E;
+end;
+
+class operator Int128.Inc(A: Int128): Int128;
+begin
+  Result := A + 1;
+end;
+
+class operator Int128.Dec(A: Int128): Int128;
+begin
+  Result := A - 1;
+end;
+
 class operator Int128.Add(A, B: Int128): Int128;
 var
@@ -368 +1096 @@
 class operator Int128.LessThanOrEqual(A, B: Int128): Boolean;
 begin
-  Result := A > B;
+  Result := not (A > B);
 end;
 
@@ -378 +1106 @@
 class operator Int128.GreaterThanOrEqual(A, B: Int128): Boolean;
 begin
-  Result := A < B;
+  Result := not (A < B);
 end;
 
 class operator Int128.Negative(A: Int128): Int128;
 begin
-  Result := (A xor Int128.MinusOne) - 1;
+  Result := (A xor Int128.MinusOne) + 1;
 end;
 
@@ -397 +1125 @@
 
 class operator Int128.IntDivide(A, B: Int128): Int128;
-begin
-
+var
+  M: Int128;
+begin
+  IntDivMod(A, B, Result, M);
 end;
 
 class operator Int128.Modulus(A, B: Int128): Int128;
-begin
-
+var
+  D: Int128;
+begin
+  IntDivMod(A, B, D, Result);
 end;
 
@@ -471 +1203 @@
   if B < 32 then begin // 1 <= B <= 31
     C := 32 - B;
-    Result.LongWords[0] := (A.LongWords[0] shr B) or (A.LongWords[1] shl C);
-    Result.LongWords[1] := (A.LongWords[1] shr B) or (A.LongWords[2] shl C);
-    Result.LongWords[2] := (A.LongWords[2] shr B) or (A.LongWords[3] shl C);
-    Result.LongWords[3] := (A.LongWords[3] shr B);
+    Result.LongWords[0] := (A.LongWords[0] shr Byte(B)) or (A.LongWords[1] shl C);
+    Result.LongWords[1] := (A.LongWords[1] shr Byte(B)) or (A.LongWords[2] shl C);
+    Result.LongWords[2] := (A.LongWords[2] shr Byte(B)) or (A.LongWords[3] shl C);
+    Result.LongWords[3] := (A.LongWords[3] shr Byte(B));
   end else
   if B < 64 then begin // 32 <= B <= 63
     D := B - 32;
     C := 32 - D;
-    Result.LongWords[0] := (A.LongWords[1] shr D) or (A.LongWords[2] shl C);
-    Result.LongWords[1] := (A.LongWords[2] shr D) or (A.LongWords[3] shl C);
-    Result.LongWords[2] := (A.LongWords[3] shr D);
+    Result.LongWords[0] := (A.LongWords[1] shr Byte(D)) or (A.LongWords[2] shl C);
+    Result.LongWords[1] := (A.LongWords[2] shr Byte(D)) or (A.LongWords[3] shl C);
+    Result.LongWords[2] := (A.LongWords[3] shr Byte(D));
     Result.LongWords[3] := 0;
   end else
@@ -487 +1219 @@
     D := B - 64;
     C := 32 - D;
-    Result.LongWords[0] := (A.LongWords[2] shr D) or (A.LongWords[3] shl C);
-    Result.LongWords[1] := (A.LongWords[3] shr D);
+    Result.LongWords[0] := (A.LongWords[2] shr Byte(D)) or (A.LongWords[3] shl C);
+    Result.LongWords[1] := (A.LongWords[3] shr Byte(D));
     Result.LongWords[2] := 0;
     Result.LongWords[3] := 0;
   end else begin           // 96 <= B <= 127
     D := B - 96;
-    Result.LongWords[0] := (A.LongWords[3] shr D);
+    Result.LongWords[0] := (A.LongWords[3] shr Byte(D));
     Result.LongWords[1] := 0;
     Result.LongWords[2] := 0;