anchor.diff:    *)
   
     // Determine minimum power of ten with which to multiply the dividend.
  -  // The + 4 is empirical.
  -//$$RV: removing the following reduces the time by 35%! (13.9s -> 8.8s)
  -  LMultiplier := RangeCheckedScale(Precision + Right.Precision - Left.Precision + 3);
  +  // Previous code used:
  +  //   LMultiplier := RangeCheckedScale(Precision + Right.Precision - Left.Precision + 3);
  +  // but the code below is 20% faster - Calculating precision can be slow.
  +  LMultiplier := RangeCheckedScale(Precision + (Right.FValue.Size - Left.FValue.Size + 1) * 9 + 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(Left.FValue * GetPowerOfTen(LMultiplier), LDivisor, LQuotient, LRemainder);
   
     // Calculate the scale that matches the division.
  -  NewScale := RangeCheckedScale(TargetScale + LMultiplier);
  +  LScale := RangeCheckedScale(TargetScale + LMultiplier);
   
     // Create a preliminary result.
  -  Result.Create(LQuotient, NewScale);
  +  Result.Create(LQuotient, LScale);
   
     // Reduce the precision, if necessary.
  -  Result := Result.RoundToScale(RangeCheckedScale(NewScale + Precision - Result.Precision), ARoundingMode);
  +  Result := Result.RoundToScale(RangeCheckedScale(LScale + 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);
  +  // This should be optional, as it is slower.
  +//  InPlaceRemoveTrailingZeros(Result, TargetScale);
   
     // Finally, set the sign of the result.
     Result.FValue.Sign := LSign;
  
positive.code:   // (1 div 25 = 0).                                                                                       //
    // So the dividend must be scaled up by at least Precision powers of ten. The end result must be rounded //
    // toward the target scale, which is Left.Scale - Right.Scale.                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
  
    if Right.FValue = BigInteger.Zero then
  
negative.code:   ARoundingMode: RoundingMode): BigDecimal;
  var
    LQuotient, LRemainder, LDivisor: BigInteger;
    LScale, TargetScale: Integer;
    LSign: Integer;
    LMultiplier: Integer;
  begin
  