anchor.diff:          MOV     EAX,[ESI]
           ADC     EAX,EDI
           MOV     [EBX],EAX
  +        JNC     @RestLoopStore0
   
           MOV     EAX,[ESI + CLimbSize]
           ADC     EAX,EDI
           MOV     [EBX + CLimbSize],EAX
  +        JNC     @RestLoopStore1
   
           MOV     EAX,[ESI + 2*CLimbSize]
           ADC     EAX,EDI
           MOV     [EBX + 2*CLimbSize],EAX
  +        JNC     @RestLoopStore2
   
           MOV     EAX,[ESI + 3*CLimbSize]
           ADC     EAX,EDI
           MOV     [EBX + 3*CLimbSize],EAX
  +        JNC     @RestLoopStore3
   
           LEA     ESI,[ESI + CUnrollIncrement*CLimbSize]
           LEA     EBX,[EBX + CUnrollIncrement*CLimbSize]
  
positive.code:     ShallowCopy(Right, Result);
  end;
  
  // Knuth, TAOCP, Vol 2 Algorithm X, p 342, but using BigIntegers.
  // Similar to https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm#Modular_integers
  class function BigInteger.ModInverse(const Value, Modulus: BigInteger): BigInteger;
  var
    u1, u3, v1, v3, t1, t3, q: BigInteger;
    iter: Integer;
  begin
    // Step X1. Initialise
  
negative.code:   while not v3.IsZero do
    begin
      // Step X3. Divide and Subtract
      DivMod(u3, v3, q, temp3);
      temp1 := Add(u1, BigInteger.Multiply(q, v1));
      // Swap
      u1 := v1;
      v1 := temp1;
      u3 := v3;
      v3 := temp3;
      Inc(iter);
    end;
    // Ensure u3, i.e. gcd(Value, Modulus) = 1
  