anchor.diff:          //let r = newEdgs
           res.AddVerticesAndEdgeRange newEdgs
           |> ignore
  -        //EpsClosure.NfaToDfa res
  -        //|> ignore
           let eps_res = EpsClosure.NfaToDfa res
           eps_res
                             
  
positive.code: [<Struct>]
  type StateInfo<'a, 'br> =
      val StartV: int
      val AccumulatedString: ResizeArray<'a>
      val Positions: ResizeArray<Position<'br>>
      new (startV, str, positions) = {StartV = startV; AccumulatedString = str; Positions = positions}
  
  [<Struct>]
  
negative.code:                     (
                          fun i ->
                              let pos = 
                                  if i.Positions.Length = 0 then None else Some i.Positions.[0] 
                                  |> newPos
                              new StateInfo<_,'br>((match stt.PreviousV with | Some x -> x | None -> i.StartV)
                              , ch :: i.AccumulatedString
                              , pos :: i.Positions)
                      )
              else 
                  new StateInfo<_,'br>((match stt.PreviousV with | Some x -> x | None -> edg.Source)
                  , [ch]
                  , [newPos (Some lexbuf.CurrentPos)])
                  |> ResizeArray.singleton
  
          let processToken onAccept (p: StateInfo<_,_>) =
              let s = (new string(p.AccumulatedString |> Array.ofList |> Array.rev))
              actions onAccept s (p.Positions |> Array.ofSeq |> Array.rev)                          
  
          let processEdg (edg:LexerEdge<_,_>) stt reduced =
              let acc = new ResizeArray<_>(10) 
  