anchor.diff:          let g = new LexerInnerGraph<'br>(inGraph)
           let sorted = g.TopologicalSort() |> Array.ofSeq
           let states = Array.init ((Array.max sorted)+1) (fun _ -> new ResizeArray<_>())
  -        let startState = new State<_,'br>(0,-1, ResizeArray.singleton (new StateInfo<_,'br>(0, [], [])))
  +        let startState = new State<_,'br>(0,-1, ResizeArray.singleton (new StateInfo<_,'br>(0, new ResizeArray<_>(), new ResizeArray<_>())))
           do states.[g.StartVertex] <- ResizeArray.singleton startState
           let edgesSeq = seq{ for v in sorted do
                                   yield g.OutEdges v |> Array.ofSeq    
  
positive.code:     let tokenize actions (lexbuf:LexBuffer<_,_>) printG =
          //let edgesSeq = edgesSeq |> Array.ofSeq
          let add (edg:LexerEdge<_,_>) (newStt:State<_,_>) =
              let x = 
                  lexbuf.States.[edg.Target]
                  |> ResizeArray.tryFind 
                      (fun (x:State<_,_>) -> x.AcceptAction = newStt.AcceptAction && x.StateID = newStt.StateID)
              match x with
              | Some x ->
                  newStt.Info
                  |> ResizeArray.iter(
                      fun i -> 
                          if x.Info.Exists(fun j -> j.StartV = i.StartV
                                                    && i.AccumulatedString.Length = j.AccumulatedString.Length
                                                    && List.forall2 (=) i.AccumulatedString j.AccumulatedString) 
                             |> not
                          then x.Info.Add i)
              | None -> lexbuf.States.[edg.Target].Add newStt
  
negative.code:                 | _ ->
                      {
                          pos_fname = ""
                          pos_lnum = 0
                          pos_bol = 0
                          pos_cnum = 0
                          back_ref = edg.BackRef.Value
  