anchor.diff:          XOR     EBX,EBX
           MOV     EAX,LSize
           MOV     LCount,EAX
  -        CMP     EAX,0
  +
  +
  +        CMP     EAX,KZero
           JE      @EndInnerLoop
   
  +        .ALIGN  16
  +
   @InnerLoop:
   
           // Loop unrolled. Approx. 70% faster than simple loop.
   
  -        MOV     EAX,[ESI]
  -        MUL     EAX,ECX
  -        ADD     EAX,[EDI]
  -        ADC     EDX,0
  -        ADD     EAX,EBX
  -        ADC     EDX,0
  -        MOV     [EDI],EAX
  -        MOV     EBX,EDX
  +        // TODO: Use MMX registers for multiplication and addition.
  +
  +        MOV     EAX,[ESI]                  // The following pattern is not faster:
  +        MUL     ECX                        // MOV    EAX,[ESI]
  +        ADD     EAX,[EDI]                  // MUL    ECX
  +        ADC     EDX,0                      // ADD    EAX,EBX
  +        ADD     EAX,EBX                    // ADC    EDX,0
  +        ADC     EDX,0                      // ADD    [EDI],EAX
  +        MOV     [EDI],EAX                  // ADC    EDX,0
  +        MOV     EBX,EDX                    // MOV    EBX,EDX
   
           MOV     EAX,[ESI + CLimbSize]
  -        MUL     EAX,ECX
  +        MUL     ECX
           ADD     EAX,[EDI + CLimbSize]
           ADC     EDX,0
           ADD     EAX,EBX
  
positive.code: 
          LEA     ESI,[ESI + 4*CLimbSize]
          LEA     EDI,[EDI + 4*CLimbSize]
          DEC     LCount
          JNE     @InnerLoop
  
  @EndInnerLoop:
  
          // The restant limbs to be handled.
  
          MOV     EAX,LRest
          MOV     LCount,EAX
  
negative.code:         MOV     [R9+4],EDX
          XOR     EAX,EAX
          MOV     EDX,CTimingLoops
  
          .ALIGN  16
  
  @ADDLoop:
  
  