anchor.diff:              if newVertex.FindIndex reduction.gssVertex.State reduction.gssVertex.Level = -1 
               then
                   let edge = new Edge(reduction.gssVertex, -parserSource.LeftSide.[reduction.prod]-1)
  -                addEdge currentGraphV isNew newVertex edge false gssVertexesToPrefixes.[reduction.gssVertex]
  +                let epsilonStartLevel = new ResizeArray<LabledPrefix<_>>()
  +                epsilonStartLevel.Add(Epsilon (reduction.gssVertex, gssVertexesToPrefixes.[reduction.gssVertex]))
  +                addEdge currentGraphV isNew newVertex edge false epsilonStartLevel
           else 
               let path = new Path(nodes.[reduction.edge.Value.Ast])
               walk (reduction.pos - 1) (reduction.edge.Value : Edge).Dest path currentGraphV nonTerm reduction.pos reduction.prod false reduction.gssVertex
  
positive.code:                             if not <| vertexesToPrefs.[v].Contains(End)
                              then
                                  vertexesToPrefs.[v].Add(gssPrefix)
                          |_ -> ignore()
  
          let rec dfs (v:VInfo<_>) =
              was.Add(v)
              collectPrefixes v
              for e in outEdgesInnerGraph.[v.vNum] do
                  collectPrefixes e.Target
                  let commonNonterms = new ResizeArray<AstNode>()
                  let targetPrefs = new ResizeArray<LabledPrefix<_>>()
  
negative.code: 
                  for notPushedPref in notPushedPrefs do
                      if not <| commonNonterms.Any(fun ast -> nonTermsAstToPrefixes.[ast].Any(fun astPrefix -> 
                                                                                                              let wasAstStarts = new ResizeArray<_>()
                                                                                                              wasAstStarts.Add(ast)
                                                                                                              let wasAst = new ResizeArray<_>()
                                                                                                              let wasFind = new ResizeArray<_>()
                                                                                                              isContainPref (Some ast) astPrefix (Some wasAstStarts) None notPushedPref None wasAst wasFind))
                      then
                          if not <| errorEdges.ContainsKey(e)
                              then
  