anchor.diff:    LSign := Left.FValue.Sign xor Right.FValue.Sign;
   
     // Use positive values (zero was discarded above).
  -  LDivisor := BigInteger.Abs(Right.FValue);
  +//  LDivisor := BigInteger.Abs(Right.FValue);
  +  LDivisor := Right.FValue;
  +
  +  (* $$RV:
  +
  +     Assume L.Precision = 12, R.Precision = 4 and desired precision = 10, then the following results in:
  +
  +       LMultiplier = 10 + 4 - 12 + 4 = 6
  +
  +     * Q: Do we really need that?
  +     * Q: Can't we calculate a rough precision instead, i.e. not use .Precision? Does that help?
  +       A: We should try to avoid calculating the BigDecimal.Precision at all.
  +     * Q: Could it be that all this scaling up and down is too expensive, and that we should try to get it right
  +          at once?
  +       A: YES!
  +     * Q: What about using a NativeUInt instead of a BigInteger for "small" values of .FValue (below MaxInt or
  +          some such).
  +
  +  *)
   
     // Determine minimum power of ten with which to multiply the dividend.
     // The + 4 is empirical.
  -  LMultiplier := RangeCheckedScale(Precision + Right.Precision - Left.Precision + 4);
  +//$$RV: removing the following reduces the time by 35%! (13.9s -> 8.8s)
  +  LMultiplier := RangeCheckedScale(Precision + Right.Precision - Left.Precision + 3);
   
     // Do the division of the scaled up dividend by the divisor. Quotient and remainder are needed.
  -  BigInteger.DivMod(BigInteger.Abs(Left.FValue) * GetPowerOfTen(LMultiplier), LDivisor, LQuotient, LRemainder);
  +//  BigInteger.DivMod(BigInteger.Abs(Left.FValue) * GetPowerOfTen(LMultiplier), LDivisor, LQuotient, LRemainder);
  +  BigInteger.DivMod(Left.FValue * GetPowerOfTen(LMultiplier), LDivisor, LQuotient, LRemainder);
   
     // Calculate the scale that matches the division.
     NewScale := RangeCheckedScale(TargetScale + LMultiplier);
   
  -  // Create a preliiminary result.
  +  // Create a preliminary result.
     Result.Create(LQuotient, NewScale);
   
     // Reduce the precision, if necessary.
  -  if Result.Precision > Precision then
  -    Result := Result.RoundToScale(RangeCheckedScale(Result.FScale + Precision - Result.Precision), ARoundingMode);
  +  Result := Result.RoundToScale(RangeCheckedScale(NewScale + Precision - Result.Precision), ARoundingMode);
   
     // remove as many trailing zeroes as possible to get as close as possible to the target scale without
     // changing the value.
  +//$$RV: removing the following reduces the time by approx 20% (30s -> 24s).
     InPlaceRemoveTrailingZeros(Result, TargetScale);
   
     // Finally, set the sign of the result.
  
positive.code:   if Right.FValue = BigInteger.Zero then
      Error(ecDivByZero, []);
    TargetScale := Left.Scale - Right.Scale;
    if Left.FValue = BigInteger.Zero then
    begin
      Result.FValue := BigInteger.Zero;
      Result.FScale := TargetScale;
  
negative.code:     Lo: Cardinal;
      Hi: Integer;
    end;
  const
    // 1292913986 is Log10(2) * 1^32.
    CMultiplier = Int64(1292913986);
  begin
    Result := FPrecision;
    if Result = 0 then
    begin
      //Note: Both 9999 ($270F) and 10000 ($2710) have a bitlength of 14, but 9999 has a precision of 4, while 10000 has a precision of 5.
      //      In other words: BitLength is not a good enough measure for precision. The test with the power of ten is necessary.
      Result := CardRec((FValue.BitLength + 1) * CMultiplier).Hi;
      if (GetPowerOfTen(Result) <= Abs(FValue)) or (Result = 0) then
        Inc(Result);
      FPrecision := Result;
  