anchor.diff:                  |Some xast ->
                       if xast = newAst
                       then
  -                        findAstPrefixes.All(fun findAstPrefix -> newAstPrefixes.Any(fun newAstPrefix -> isContainPref None newAstPrefix nextFindAst findAstPrefix))
  +                        match wasFindStarts with
  +                        |Some starts ->
  +                            if starts.Contains(curFindAst)
  +                            then
  +                                true
  +                            else
  +                                starts.Add(curFindAst)
  +                                findAstPrefixes.All(fun findAstPrefix -> newAstPrefixes.Any(fun newAstPrefix -> isContainPref None newAstPrefix wasAstStarts nextFindAst findAstPrefix wasFindStarts))
  +                        |None ->
  +                            let newWasFindStarts = new ResizeArray<_>()
  +                            newWasFindStarts.Add(curFindAst)
  +                            findAstPrefixes.All(fun findAstPrefix -> newAstPrefixes.Any(fun newAstPrefix -> isContainPref None newAstPrefix wasAstStarts nextFindAst findAstPrefix (Some newWasFindStarts)))
                       else
                           false
                   |None ->
  
positive.code:             |(Pref astPref, Pref findPref) ->
                  if astPref.Head = findPref.Head
                  then
                      findPref.Tail.All(fun findTail -> astPref.Tail.Any(fun astTail -> isContainPref ast astTail findAst findTail))
                  else
                      false
              |(Pref astPref, NontermStart (curFindAst, findAstPrefixes)) ->
                  let nextFindAst = getNewAst findAst curFindAst
                  findAstPrefixes.All(fun findAstPrefix -> isContainPref ast curAstPrefix nextFindAst findAstPrefix)
              |(Pref astPref, NontermEnd (curFindAst, findAstPrefixes)) ->
                  match findAst with
                  |Some fast ->
                      if fast = curFindAst
                      then
                          findAstPrefixes.All(fun findAstPrefix -> isContainPref ast curAstPrefix None findAstPrefix)
                      else
                          true
                  |None ->
  
negative.code:             for napref in notAccPrefs do
                  if not <| accPrefs.Contains(napref)
                  then
                      if not <| accNonterms.Any(fun ast -> nonTermsAstToPrefixes.[ast].Any(fun astPrefix ->   let wasAst = new ResizeArray<_>()
                                                                                                              wasAst.Add(ast)
                                                                                                              isContainPref (Some ast) astPrefix (Some wasAst) None napref None))
                      then
                          errorEdges.Add(e, new ResizeArray<_>())
                          addPrefix errorEdges.[e] napref //added napref, which contain some error prefixes
  
          buildErrors errorEdges
  
  