anchor.diff:      else
           let epsilon = new Nodes()
           let setR = new Queue<Context>();   
  -        let setP = new Queue<Vertex * obj>();    
  +        let setP = new ResizeArray<PoppedPair>();    
          // let setP = new System.Collections.Generic.Dictionary<Vertex,ResizeArray<obj>> (new VComparer())
           let setU = Array.init (inputLength + 1) (fun _ -> new ResizeArray<PreviousContexts>())  //temp проверять не был ли уже такой добавлен
               
  
positive.code:             if not (Vertex.Equal u dummyGSSNode)
              then
                  let label = u.Label
                  setP.Enqueue(u, z)
                  let processEdge (edge : Edge) =
                      let y1 = getNodeP label edge.Ast z
                      addContext label i edge.Dest y1    
  
negative.code:                 curLevel.Add result   
              result
  
          let containsEdge (b : Vertex) (e : Vertex) (ast : obj) =
              let edges = b.OutEdges
              edges.first <> Unchecked.defaultof<_>
              && ( Vertex.Equal edges.first.Dest e && ast.Equals edges.first.Ast 
                   || (edges.other <> null && edges.other |> Array.exists (fun edge -> Vertex.Equal edge.Dest e && ast.Equals edge.Ast)))
  
          let findTree prod extension family =            
              let currentNonTerm = parser.LeftSide.[prod]            
              let result =
                  setP
                  |> ResizeArray.tryFind
                      (fun pair ->     
                          match pair.Ast with
                          | :? AST as a -> parser.LeftSide.[a.first.prod] = currentNonTerm && a.extension = extension                
                          | _ -> failwith "Unexpected type of tree.")            
                  |> Option.map
                   (fun p ->
                      let a = p.Ast :?> AST
                      if not <| (a.first.Equals family || (a.other <> null && a.other |> Array.exists(family.Equals)))
                      then
                          if a.other <> null
                          then a.other <- Array.append a.other [|family|]
                          else a.other <- [|family|]
                      a)
                          
  //            for pair in setP do
  //                match pair.Ast with
  //                | :? AST as a -> 
  //                    if parser.LeftSide.[a.first.prod] = currentNonTerm && a.extension = extension
  //                    then
  //                        wasAdded <- a.first.Equals family || (a.other <> null && a.other |> Array.exists(family.Equals))                        
  //                        if not wasAdded
  //                        then
  //                            if a.other <> null
  //                            then a.other <- Array.append a.other [|family|]
  //                            else a.other <- [|family|]
  //                        result := Some a
  //                | _ -> failwith "Unexpected type of tree."
  
              let result =
                  match result with
                  | Some tree -> tree
                  | None -> new AST(family, null, extension)
              result
  