anchor.diff:  
   class operator BigInteger.Multiply(Left: Word; const Right: BigInteger): BigInteger;
   begin
  -  Result := Right * Left;
  +  if (Left = 0) or ((Right.FSize and SizeMask) = 0) then
  +    Exit(Zero);
  +  Result.MakeSize((Right.FSize and SizeMask) + 2);
  +  InternalMultiplyAndAdd16(Right.FData, Left, 0, Result.FData);
  +  Result.FSize := (Right.FSize and SignMask) or (Result.FSize and SizeMask);
  +  Result.Compact;
   end;
   
   class function BigInteger.MultiplyKaratsuba(const Left, Right: BigInteger): BigInteger;
  
positive.code:        MOV     EBX,EDX
         INC     R11D
         CMP     R11D,R10D
         JB      @@2
  @@3:
         MOV     [R9 + CLimbSize*R11],EDX
         POP     RDX                      // POP Extra
         XOR     EBX,EBX
  @@4:
         ADC     [R9 + CLimbSize*RBX],EDX
         JNC     @Exit
         MOV     EDX,0                    //
         INC     EBX                      // These 3 instructions should not modify the carry flag!
         DEC     R10D                     //
         JNE     @@4
  @Exit:
  end;
  {$ENDIF WIN64}
  
negative.code:     ShallowCopy(Right, Result);
  end;
  
  // Knuth, TAOCP, Vol 2 Algorithm X, p 342, but using BigIntegers.
  class function BigInteger.ModInverse(const Value, Modulus: BigInteger): BigInteger;
  var
    u1, u3, v1, v3, t1, t3, q: BigInteger;
    iter: Integer;
  begin
    // Step X1. Initialise
    u1 := One;
    u3 := Abs(Value);
    v1 := Zero;
  