anchor.diff:        opJMP=4;
         opSPLIT=5;
         opSAVE=6;
  -      opBOL=8;
  -      opEOL=9;
  -      opBOT=10;
  -      opEOT=11;
  -      opBRK=12;
  -      opNBRK=13;
  -      opLOOKBEHINDNEGATIVE=14;
  -      opLOOKBEHINDPOSITIVE=15;
  -      opLOOKAHEADNEGATIVE=16;
  -      opLOOKAHEADPOSITIVE=17;
  +      opBOL=7;
  +      opEOL=8;
  +      opBOT=9;
  +      opEOT=10;
  +      opBRK=11;
  +      opNBRK=12;
  +      opLOOKBEHINDNEGATIVE=13;
  +      opLOOKBEHINDPOSITIVE=14;
  +      opLOOKAHEADNEGATIVE=15;
  +      opLOOKAHEADPOSITIVE=16;
  +      opBACKREFERENCE=17;
  +      opBACKREFERENCEIGNORECASE=18;
   
         // Split kind
         skALT=0;
  
positive.code:         Emit(Node^.Left);
          Instructions[i0].OtherNext:=pointer(ptrint(CountInstructions));
         end;
        end else if Node^.MaxCount<0 then begin
         if Node^.MinCount>0 then begin
          // Infinity with minimum connt
          for Counter:=1 to Node^.MinCount-1 do begin
           Emit(Node^.Left);
          end;
          i0:=CountInstructions;
          Emit(Node^.Left);
          i1:=NewInstruction(opSPLIT);
          Instructions[i1].Value:=skPLUS;
          if Node^.Value<>0 then begin
           // Non-greedy
           Instructions[i1].OtherNext:=pointer(ptrint(i0));
           Instructions[i1].Next:=pointer(ptrint(CountInstructions));
          end else begin
           // Greedy
           Instructions[i1].Next:=pointer(ptrint(i0));
           Instructions[i1].OtherNext:=pointer(ptrint(CountInstructions));
          end;
         end else begin
          // Infinity without minimum connt
          i0:=NewInstruction(opSPLIT);
          Instructions[i0].Value:=skSTAR;
          if Node^.Value<>0 then begin
           // Non-greedy
           Instructions[i0].OtherNext:=pointer(ptrint(CountInstructions));
           Emit(Node^.Left);
           i1:=NewInstruction(opJMP);
           Instructions[i1].Next:=pointer(ptrint(i0));
           Instructions[i0].Next:=pointer(ptrint(CountInstructions));
          end else begin
           // Greedy
           Instructions[i0].Next:=pointer(ptrint(CountInstructions));
           Emit(Node^.Left);
           i1:=NewInstruction(opJMP);
           Instructions[i1].Next:=pointer(ptrint(i0));
           Instructions[i0].OtherNext:=pointer(ptrint(CountInstructions));
          end;
         end;
        end else begin
         for Counter:=1 to Node^.MinCount do begin
          Emit(Node^.Left);
         end;
         if Node^.MinCount<Node^.MaxCount then begin
          if (Node^.MaxCount-Node^.MinCount)<1024 then begin
           SetLength(Last,Node^.MaxCount-Node^.MinCount);
           try
            for Counter:=Node^.MinCount to Node^.MaxCount-1 do begin
             i0:=NewInstruction(opSPLIT);
             Instructions[i0].Value:=skQUEST;
             Last[Counter-Node^.MinCount]:=i0;
             if Node^.Value<>0 then begin
              // Non-greedy
              Instructions[i0].OtherNext:=pointer(ptrint(CountInstructions));
             end else begin
              // Greedy
              Instructions[i0].Next:=pointer(ptrint(CountInstructions));
             end;
             Emit(Node^.Left);
            end;
            for Counter:=Node^.MaxCount-1 downto Node^.MinCount do begin
             i0:=Last[Counter-Node^.MinCount];
             if Node^.Value<>0 then begin
              // Non-greedy
              Instructions[i0].Next:=pointer(ptrint(CountInstructions));
             end else begin
              // Greedy
              Instructions[i0].OtherNext:=pointer(ptrint(CountInstructions));
             end;
            end;
           finally
            SetLength(Last,0);
           end;
          end else begin
           for Counter:=Node^.MinCount to Node^.MaxCount-1 do begin
            i0:=NewInstruction(opSPLIT);
            Instructions[i0].Value:=skQUEST;
            if Node^.Value<>0 then begin
             // Non-greedy
             Instructions[i0].OtherNext:=pointer(ptrint(CountInstructions));
             Emit(Node^.Left);
             Instructions[i0].Next:=pointer(ptrint(CountInstructions));
            end else begin
             // Greedy
             Instructions[i0].Next:=pointer(ptrint(CountInstructions));
             Emit(Node^.Left);
             Instructions[i0].OtherNext:=pointer(ptrint(CountInstructions));
            end;
           end;
          end;
         end;
        end;
       end;
       ntBOL:begin
        if Reversed then begin
         i0:=NewInstruction(opEOL);
        end else begin
         i0:=NewInstruction(opBOL);
        end;
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
       end;
       ntEOL:begin
        if Reversed then begin
         i0:=NewInstruction(opBOL);
        end else begin
         i0:=NewInstruction(opEOL);
        end;
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
       end;
       ntBOT:begin
        if Reversed then begin
         i0:=NewInstruction(opEOT);
        end else begin
         i0:=NewInstruction(opBOT);
        end;
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
       end;
       ntEOT:begin
        if Reversed then begin
         i0:=NewInstruction(opBOT);
        end else begin
         i0:=NewInstruction(opEOT);
        end;
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
       end;
       ntBRK:begin
        i0:=NewInstruction(opBRK);
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
       end;
       ntNBRK:begin
        i0:=NewInstruction(opNBRK);
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
       end;
       ntLOOKBEHINDNEGATIVE:begin
        i0:=NewInstruction(opLOOKBEHINDNEGATIVE);
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
        Instructions[i0].Value:=Node^.Value;
       end;
       ntLOOKBEHINDPOSITIVE:begin
        i0:=NewInstruction(opLOOKBEHINDPOSITIVE);
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
        Instructions[i0].Value:=Node^.Value;
       end;
       ntLOOKAHEADNEGATIVE:begin
        i0:=NewInstruction(opLOOKAHEADNEGATIVE);
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
        Instructions[i0].Value:=Node^.Value;
       end;
       ntLOOKAHEADPOSITIVE:begin
        i0:=NewInstruction(opLOOKAHEADPOSITIVE);
        Instructions[i0].Next:=pointer(ptrint(CountInstructions));
        Instructions[i0].Value:=Node^.Value;
       end;
       else begin
        raise EFLRE.Create('Internal error');
       end;
      end;
      break;
  
negative.code:        inc(SourcePosition);
         if SourcePosition<=SourceLength then begin
          case Source[SourcePosition] of
           '0'..'9':begin
            Value:=CountInternalCaptures;
            inc(CountInternalCaptures);
            if rfIGNORECASE in Flags then begin
             result:=NewNode(ntBACKREFERENCEIGNORECASE,nil,nil,nil,Value);
            end else begin
             result:=NewNode(ntBACKREFERENCE,nil,nil,nil,Value);
            end;
            result^.Group:=byte(ansichar(Source[SourcePosition]))-byte(ansichar('0'));
            inc(SourcePosition);        
           end;
           'b','y':begin
            result:=NewNode(ntBRK,nil,nil,nil,0);
            inc(SourcePosition);
  