anchor.diff:          member lexbuf.BufferLocalStore = (context :> IDictionary<_,_>)
           member lexbuf.LexemeLength with get() : int = lexemeLength and set v = lexemeLength <- v
           member x.CountPosLine = count_pos_line
  -        member x. PreviousV =  prevV
           member x.States = states
           member x.Edges = edgesSeq
           member x.LastVId = sorted.[sorted.Length-1]
  
positive.code: [<Struct>]
  type StateInfo<'a, 'br> =
      val StartV: int
      val PreviousV: int
      val AccumulatedString: ResizeArray<'a>
      val Positions: ResizeArray<Position<'br>>
      new (startV, previousV, str, positions) = {StartV = startV; PreviousV = previousV; AccumulatedString = str; Positions = positions}
  
  [<Struct>]
  type State<'a, 'br> =
  
negative.code:                             let pos = 
                                  if i.Positions.Count = 0 then None else Some i.Positions.[0] 
                                  |> newPos
                              new StateInfo<_,'br>((match stt.PreviousV with | Some x -> x | None -> i.StartV)
                              , ResizeArray.concat [i.AccumulatedString; ResizeArray.singleton ch]
                              , ResizeArray.concat [ResizeArray.singleton pos; i.Positions])
                      )
              else 
                  new StateInfo<_,'br>((match stt.PreviousV with | Some x -> x | None -> edg.Source), ResizeArray.singleton ch, ResizeArray.singleton (newPos None))
                  |> ResizeArray.singleton
  
          let processToken onAccept (p: StateInfo<_,_>) =
  