anchor.diff:      LSize := RSize;
       RSize := I;
     end;
  -  // From here on,
  -  // - Left is larger and LSize is its size,
  -  // - Right is smaller and RSize is its size.
  -
  -  // Emulate ADC (add with carry)
  -{$IFNDEF CPU64BITS}
  -  CarryIn := False;
  -{$ELSE}
  -  Carry64 := 0;
  -{$ENDIF}
  -  Dec(LSize, RSize);
  +
  +  Sum := 0;
  +
  +  Dec(LSize, RSize);          // LSize is length of non-overlapping part.
   
     LTail := RSize and CUnrollMask;
     LCount := RSize shr CUnrollShift;
   
     while LCount > 0 do
     begin
  -{$IFDEF CPU64BITS}
  -    Left64 := PUInt64(Left)[0];
  -    Sum64 := Left64 + PUInt64(Right)[0];
  -    CarryOut64 := Ord(Sum64 < Left64);
  -    Inc(Sum64, Carry64);
  -    PUInt64(Result)[0] := Sum64;
  -    Carry64 := CarryOut64 or Ord(Sum64 < Carry64);
  -
  -    Left64 := PUInt64(Left)[1];
  -    Sum64 := Left64 + PUInt64(Right)[1];
  -    CarryOut64 := Ord(Sum64 < Left64);
  -    Inc(Sum64, Carry64);
  -    PUInt64(Result)[1] := Sum64;
  -    Carry64 := CarryOut64 or Ord(Sum64 < Carry64);
  -{$ELSE !CPU64BITS}
  -    Sum := Left[0] + Right[0];
  -    CarryOut := Sum < Left[0];
  -    Inc(Sum, Byte(CarryIn));
  -    Result[0] := Sum;
  -    CarryIn := (Sum < Byte(CarryIn)) or CarryOut;
  -
  -    Sum := Left[1] + Right[1];
  -    CarryOut := Sum < Left[1];
  -    Inc(Sum, Byte(CarryIn));
  -    Result[1] := Sum;
  -    CarryIn := (Sum < Byte(CarryIn)) or CarryOut;
  -
  -    Sum := Left[2] + Right[2];
  -    CarryOut := Sum < Left[2];
  -    Inc(Sum, Byte(CarryIn));
  -    Result[2] := Sum;
  -    CarryIn := (Sum < Byte(CarryIn)) or CarryOut;
  -
  -    Sum := Left[3] + Right[3];
  -    CarryOut := Sum < Left[3];
  -    Inc(Sum, Byte(CarryIn));
  -    Result[3] := Sum;
  -    CarryIn := (Sum < Byte(CarryIn)) or CarryOut;
  -{$ENDIF}
  +    Sum := UInt64(Left[0]) + Right[0] + (Sum shr 32);
  +    Result[0] := TLimb(Sum);
  +
  +    Sum := UInt64(Left[1]) + Right[1] + (Sum shr 32);
  +    Result[1] := TLimb(Sum);
  +
  +    Sum := UInt64(Left[2]) + Right[2] + (Sum shr 32);
  +    Result[2] := TLimb(Sum);
  +
  +    Sum := UInt64(Left[3]) + Right[3] + (Sum shr 32);
  +    Result[3] := TLimb(Sum);
  +
       Inc(Left, CUnrollIncrement);
       Inc(Right, CUnrollIncrement);
       Inc(Result, CUnrollIncrement);
       Dec(LCount);
     end;
  -
  -{$IFDEF CPU64BITS}
  -  CarryIn := Boolean(Carry64);
  -{$ELSE}
  -//  Carry := Byte(CarryIn);
  -{$ENDIF}
     while LTail > 0 do
     begin
  -    Sum := Left[0] + Right[0];
  -    CarryOut := Sum < Left[0];
  -    Inc(Sum, Byte(CarryIn));
  -    Result[0] := Sum;
  -    CarryIn := (Sum < Byte(CarryIn)) or CarryOut;
  +    Sum := UInt64(Left[0]) + Right[0] + (Sum shr 32);
  +    Result[0] := TLimb(Sum);
   
       Inc(Left);
       Inc(Right);
  
positive.code: 
  // Setting PUREPASCAL forces the use of plain Object Pascal for all routines, i.e. no assembler is used.
  
    { $DEFINE PUREPASCAL}
  
  
  // Setting RESETSIZE forces the Compact routine to shrink the dynamic array when that makes sense.
  
negative.code:   SNoInverse                 = 'No modular inverse possible';
    SNegativeExponent          = 'Negative exponent %s not allowed';
  
  {$RANGECHECKS OFF}
  {$OVERFLOWCHECKS OFF}
  {$POINTERMATH ON}
  {$STACKFRAMES OFF}
  