anchor.diff:    Result.Compact;
   end;
   
  +function BigInteger.LowestSetBit: Integer;
  +var
  +  I: Integer;
  +begin
  +  if FData = nil then
  +    Exit(-1);
  +  I := 0;
  +  Result := 0;
  +  while FData[I] = 0 do
  +  begin
  +    Inc(Result, CLimbBits);
  +    Inc(I);
  +  end;
  +  Inc(Result, LowestOneBit(FData[I]));
  +end;
  +
   class function BigInteger.Max(const Left, Right: BigInteger): BigInteger;
   begin
     if Left > Right then
  
positive.code:   Result.Compact;
  end;
  
  class operator BigInteger.Negative(const Value: BigInteger): BigInteger;
  begin
    // Magnitude is not modified, so a shallow copy is enough!
  
negative.code:     /// <summary>The function equivalent to the operator 'div'.</summary>
      class function Divide(const Left:BigInteger; Right: UInt32): BigInteger; overload; static;
  
      /// <summary>The function equivalent to the operator 'mod'. Like for integers, the remainder gets
      ///   the sign - if any - of the dividend (i.e. of Left).</summary>
      class function Remainder(const Left, Right: BigInteger): BigInteger; overload; static;
  
      /// <summary>The function equivalent to the operator 'mod'. Like for integers, the remainder gets
      ///   the sign - if any - of the dividend (i.e. of Left).</summary>
      class function Remainder(const Left: BigInteger; Right: UInt32): BigInteger; overload; static;
  
      /// <summary>The function equivalent to the operator 'mod'. Like for integers, the remainder gets
      ///   the sign - if any - of the dividend (i.e. of Left).</summary>
      class function Remainder(const Left: BigInteger; Right: UInt16): BigInteger; overload; static;
  
      class function SqrKaratsuba(const Value: BigInteger): BigInteger; static;
  
      /// <summary>Returns the negation of Value.</summary>
      class function Negate(const Value: BigInteger): BigInteger; static;
  
  
      // -- Self-referential operator functions --
  