anchor.diff:  
       out.WriteLine "}"
       out.Close()
  +
  +let recoverDfa (dfaList : int[][][]) (amountOfStates : int[]) = 
  +    let prodCount = dfaList.Length
  +    let symbCount =
  +        match prodCount with
  +        | 0 -> 0
  +        | _ -> dfaList.[0].Length
  +    let res = Array.zeroCreate prodCount
  +    for i = 0 to prodCount - 1 do
  +        let amount = amountOfStates.[i]
  +        res.[i] <- Array.zeroCreate amount
  +        for j = 0 to amount - 1 do
  +            res.[i].[j] <- Array.zeroCreate symbCount
  +        for k = 0 to symbCount - 1 do
  +            let states = dfaList.[i].[k]
  +            for s = 0 to states.Length - 1 do
  +                if s % 2 = 0 then res.[i].[states.[s]].[k] <- states.[s + 1]
  +    res
  +
  +let recoverFiniteStates (finiteStates : int[][]) = 
  +    let res : HashSet<int>[] = Array.zeroCreate finiteStates.Length
  +    for i = 0 to finiteStates.Length - 1 do
  +        res.[i] <- new HashSet<_>()
  +        for el in finiteStates.[i] do
  +            res.[i].Add(el) |> ignore
  +    res
   
   type ReduceLabel =
       |Reduce
  
positive.code:                 | Some x ->
                      let push = x
                      // Push to init state is impossible
                      if fst push <> 0 then
                          pushes.Push (v, push)
                  | None -> ()
                  let arr = parserSource.ZeroReduces.[state].[!curNum]
  
negative.code: 
  /// Add edges, what must be unique (after shift or epsilon-edges).
  /// All edges are sorted by destination ascending.
  let private addSimpleEdge (v : Vertex) (ast : obj) (out : ResizeArray<Vertex * obj>) =
      let inline fst2 (x,_) = x
      let inline snd2 (_,x) = x
      let mutable i = out.Count - 1
      while i >= 0 && less (fst2 out.[i]) v do
          i <- i - 1
      while i >= 0 && eq (fst2 out.[i]) v do
          i <- i - 1
      out.Insert (i+1, (v, ast))
  
  /// Check if edge with specified destination and AST already exists
  let private containsSimpleEdge (v : Vertex) (f : obj) (out : ResizeArray<Vertex * obj>) =
      let inline fst2 (x,_) = x
      let inline snd2 (_,x) = x
      let mutable i = out.Count - 1
      while i >= 0 && less (fst2 out.[i]) v do
          i <- i - 1
      while i >= 0 && eq (fst2 out.[i]) v do
          i <- i - 1
      while i >= 0 && (let v',f' = out.[i] in eq v' v && f <> f') do
          i <- i - 1
      i >= 0 && (let v',f' = out.[i] in eq v' v && f = f')
  
  /// Add or extend edge with specified destination and family.
  /// All edges are sorted by destination ascending.
  let private addEdge (v : Vertex) (family : Family) (out : ResizeArray<Vertex * Family * AST>) isError =
      let mutable i = out.Count - 1
      let inline fst3 (x,_,_) = x
      let inline snd3 (_,x,_) = x
      let inline trd3 (_,_,x) = x
      while i >= 0 && less (fst3 out.[i]) v do
          i <- i - 1
      while i >= 0 && eq (fst3 out.[i]) v do
          i <- i - 1
  
      let isCreated = not (i >= 0 && eq (fst3 out.[i]) v)
  
      let ast = 
          if isError
          then new AST(family, null)
          else 
              if not isCreated 
              then let _,_,n = out.[i] in n
              else new AST (Unchecked.defaultof<_>, null)
      let newVal = v, family, ast
      if isCreated || family.prod = (snd3 out.[i]).prod then
          out.Insert (i+1, newVal)
      elif family.prod < (snd3 out.[i]).prod then
          out.[i] <- newVal
          let mutable j = i-1
          while j >= 0 && eq (fst3 out.[j])  (fst3 out.[i]) do
              j <- j - 1
          out.RemoveRange(j+1, i-j-1)
      isCreated, ast
  
  /// Check if edge with specified destination and family already exists
  let private containsEdge (v : Vertex) (f : Family) (out : ResizeArray<Vertex * Family * AST>) =
      let inline fst3 (x,_,_) = x
      let inline snd3 (_,x,_) = x
      let mutable i = out.Count - 1
      while i >= 0 && less (fst3 out.[i]) v do
          i <- i - 1
      while i >= 0 && eq (fst3 out.[i]) v do
          i <- i - 1
      while i >= 0 && (let v',f',_ = out.[i] in eq v' v && f <> f') do
          i <- i - 1
      i >= 0 && (let v',f',_ = out.[i] in eq v' v && f = f')
  
  let drawDot (tokenToNumber : _ -> int) (tokens : BlockResizeArray<_>) (leftSide : int[])
          (initNodes : seq<Vertex>) (numToString : int -> string) (errInd: int) (path : string) =
  