anchor.diff:          let edges = Array.init statesCount (fun _ -> new ResizeArray<Vertex * Family * AST>())
           let simpleEdges = Array.init statesCount (fun _ -> new ResizeArray<Vertex * obj>())
           let pushes = ref [||]
  -        let pushesInitFun l =
  -            pushes := Array.init l (fun _ -> new Stack<_> (statesCount * 2 + 10))
  +        let pushesInitFun l = 
  +            pushes := Array.init l (fun _ -> new Stack<_> (statesCount * 2 + 10))  
           pushesInitFun curTokens.Value.Tokens.Length
           /// Stores states, used on current level. Instead statesCount must be number of non-terminals, but doesn't matter
           let usedStates = new Stack<_>(statesCount)
           let stateToVertex : Vertex[] = Array.zeroCreate statesCount
   
           let addVertex vertData =
  -            let inline mapFn (state, level, (edgeOpt : option<Vertex * obj>)) =
  +            [|
  +            for (state, level, (edgeOpt : option<Vertex * obj>)) in vertData |> Array.sortBy (fun (_,x,_) -> -x) do
                   let curNums = if !isEOF then [|parserSource.EofIndex|] else curTokens.Value.Tokens |> Array.map (fun t -> t.CurNum)
                   if stateToVertex.[state] = null then
                       let v = new Vertex(state, level)
  
positive.code:                                 while j < edges.Count && trd edges.[j] = a do
                                      j <- j + 1
                                  i <- j
  
                  if pos = 0 then
                      let state = parserSource.Gotos.[vertex.State].[nonTerm]
                      addVertex [|state, !curLvl, None|] |> ignore
                      let ast = getEpsilon parserSource.LeftSide.[prod]
                      if not <| containsSimpleEdge vertex ast simpleEdges.[state] then
                          addSimpleEdge vertex ast simpleEdges.[state]
                  else
                      let path = Array.zeroCreate pos
                      path.[pos - 1] <- snd edgeOpt.Value
                      walk (pos - 1) (fst edgeOpt.Value) path
  
          let curInd = ref 0
          let isEnd = ref false
  
          let attachEdges () =
              let inline snd3 (_,x,_) = x
              for vertex in usedStates do
  
negative.code:     for v in initNodes do
          if not <| was.ContainsKey v then
              dfs v
      
      for level in levels do
          print <| sprintf "{rank=same; %s}" (level.Value |> List.map (fun (u : int) -> string u) |> String.concat " ")
  
  