anchor.diff:    y := Right.Split(k, 2);
   
     // Recursion further reduces the number of multiplications!
  -  z2 := MultiplyKaratsuba(x[1], y[1]);
  -  z0 := MultiplyKaratsuba(x[0], y[0]);
  -  z1 := MultiplyKaratsuba(x[1] - x[0], y[0] - y[1]) + (z2 + z0);
  +  MultiplyKaratsuba(x[1], y[1], z2);
  +  MultiplyKaratsuba(x[0], y[0], z0);
  +  MultiplyKaratsuba(x[1] - x[0], y[0] - y[1], z1);
  +  Add(z1, z2 + z0, z1);
   
     Result := z0;
     Result.AddWithOffset(z2, k * 2);
  
positive.code:   Result.Compact;
  end;
  
  class function BigInteger.MultiplyKaratsuba(const Left, Right: BigInteger): BigInteger;
  var
    k, LSign: Integer;
    z0, z1, z2: BigInteger;
    x, y: TArray<BigInteger>;
  begin
    if ((Left.FSize and SizeMask) < KaratsubaThreshold) or ((Right.FSize and SizeMask) < KaratsubaThreshold) then
      Exit(MultiplyBaseCase(Left, Right));
  
    //////////////////////////////////////////////////////////////////////////////////////////////////
    ///  This is a so called divide and conquer algorithm, solving a big task by dividing it up    ///
  
negative.code:     class function Multiply(const Left, Right: BigInteger): BigInteger; overload; static;
  
      /// <summary>Function performing "schoolbook" multiplication.</summary>
      class procedure MultiplyBaseCase(const Left, Right: BigInteger; var Result: BigInteger); static;
  
      /// <summary>Function performing multiplcation using Karatsuba algorithm. Has more overhead, so only
      ///  applied to large BigIntegers.</summary>
      class procedure MultiplyKaratsuba(const Left, Right: BigInteger; var Result: BigInteger); static;
  
      /// <summary>Function performing multiplication using Toom-Cook 3-way algorithm. Faster than Karatsuba, but,
      /// due to its overhead, only for very large BigIntegers.</summary>
  