anchor.diff:          actionVInvBool.[v] <- true       
               
       let tokensInv = new ResizeArray<_>() 
  -
  -    let bfs vertex (graphFst: FST<_,_>) (visited: ResizeArray<_>) =
  +    let visited = new HashSet<_>()
  +
  +    let bfs vertex (graphFst: FST<_,_>) =
           let targetAct = new HashSet<_>()
           let edgesToks = new ResizeArray<_>()            
           let queueV = new Queue<_>()
  
positive.code:                             else queueV.Enqueue v.Target
                          else 
                              targetAct.Add v.Source |> ignore   
                                             
          let gr = new GraphTokenValue<_>() 
          gr.AddVerticesAndEdgeRange edgesToks |> ignore
          new GraphAction<_>(vertex, targetAct, gr)      
      let visited = ResizeArray.init (!maxV + 1) (fun _ -> false)        
      for act in actionV do 
          bfs act inputFstLexer visited |> tokens.Add |> ignore
          visited |> ResizeArray.iteri(fun i x -> visited.[i] <- false)
  
      let bfsInv vertex (graphFst: FST<_,_>) (visited: ResizeArray<_>) =
          let targetAct = new HashSet<_>()
          let edgesToks = new ResizeArray<_>()            
          let queueV = new Queue<_>()
          queueV.Enqueue(vertex)               
  
          //let isAct v = Set.exists ((=) v) actionVInv
          let isEps v = inputFstLexer.OutEdges(v) |> Seq.exists(fun x -> x.Tag.OutSymb = Eps) 
  
          while queueV.Count > 0 do
              let topV = queueV.Dequeue()
              if not <| visited.[topV]
              then
                  visited.[topV] <- true
                  for v in graphFst.OutEdges(topV) do
                      new TokenEdge<_>(v.Target, v.Source, match v.Tag.InSymb with |Smbl y -> y | _ -> failwith "Unexpected!!!" ) |> edgesToks.Add |> ignore
                      if actionVInvBool.[v.Target]
                      then if (isEps v.Target) then queueV.Enqueue(v.Target)
                      else queueV.Enqueue(v.Target)  
                                             
          let gr = new GraphTokenValue<_>() 
          gr.AddVerticesAndEdgeRange edgesToks |> ignore
          new GraphAction<_>(vertex, targetAct, gr) 
  
      for act in actionVInv do
          //let visitedInv = ResizeArray.init (!maxV + 1) (fun _ -> false)
          bfsInv act FstInverse visited |> tokensInv.Add |> ignore     //if from vertex exist and act-edge and eps-edge, then continue add edges.
          visited |> ResizeArray.iteri(fun i x -> visited.[i] <- false)
  
      let EqualEdges (edg1:TokenEdge<_>) (edg2:TokenEdge<_>) = 
          (edg1.Source = edg2.Source) && (edg1.Target = edg2.Target) && (edg1.Label = edg2.Label) && (edg1.BackRef = edg2.BackRef) //smth else?
  
negative.code:         let isStartV v = ResizeArray.exists ((=) v) inputFstLexer.InitState
          while queueV.Count > 0 do
              let topV = queueV.Dequeue()
              if not <| visited.Contains(topV) 
              then
                  visited.Add(topV) |> ignore
                  for v in graphFst.OutEdges(topV) do
                      if v.Tag.OutSymb = Eps
                      then 
  