anchor.diff:  //    let qGraph = loadDotToQG gFile
   //    let lexerInputG = new LexerInputGraph<_>()
   //    lexerInputG.StartVertex <- 0
  -//    for e in qGraph.Edges do lexerInputG.AddEdgeForsed (new ParserEdge<_>(e.Source,e.Target,(Some e.Tag, Some e.Tag)))
  +//    for e in qGraph.Edges do lexerInputG.AddEdgeForsed (edg e.Source,e.Target,(Some e.Tag, Some e.Tag)))
   //    lexerInputG
   
  -
  -
  -
   let lbl tokenId = tokenId
  +let edg f t l = new ParserEdge<_>(f,t,lbl l)
   
   let loadLexerInputGraph gFile =
       let qGraph = loadDotToQG gFile
  
positive.code: 
      [<Test>]
      member this.``Simple calc. Sequence input.`` () =
          let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [new AbstractParsing.Common.ParserEdge<_>(0,1,lbl <| RNGLR.ParseSimpleCalc.NUM 1)
               new AbstractParsing.Common.ParserEdge<_>(1,2,lbl <| RNGLR.ParseSimpleCalc.PLUS 0)
               new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.ParseSimpleCalc.NUM 2)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseSimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Yard.Generators.RNGLR.Parser.Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseSimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Sequence input.`` () =
          let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [new AbstractParsing.Common.ParserEdge<_>(0,1,lbl <| RNGLR.ParseCalc.NUMBER  1)
               new AbstractParsing.Common.ParserEdge<_>(1,2,lbl <| RNGLR.ParseCalc.PLUS 0)
               new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.ParseCalc.NUMBER 2)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Yard.Generators.RNGLR.Parser.Success(tree, _ ,_) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Branched input.`` () =
          let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [new AbstractParsing.Common.ParserEdge<_>(0,1,lbl <| RNGLR.ParseCalc.NUMBER  1)
               new AbstractParsing.Common.ParserEdge<_>(1,2,lbl <| RNGLR.ParseCalc.PLUS 0)
               new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.ParseCalc.NUMBER 2)
               new AbstractParsing.Common.ParserEdge<_>(3,4,lbl <| RNGLR.ParseCalc.MULT 3)
               new AbstractParsing.Common.ParserEdge<_>(4,5,lbl <| RNGLR.ParseCalc.NUMBER 4)
               new AbstractParsing.Common.ParserEdge<_>(3,6,lbl <| RNGLR.ParseCalc.DIV 5)
               new AbstractParsing.Common.ParserEdge<_>(6,5,lbl <| RNGLR.ParseCalc.NUMBER 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | Yard.Generators.RNGLR.Parser.Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Branched input error.`` () =
          let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               new AbstractParsing.Common.ParserEdge<_>(0,3,lbl <| RNGLR.ParseCalc.NUMBER 2)
               new AbstractParsing.Common.ParserEdge<_>(3,4,lbl <| RNGLR.ParseCalc.MULT 3)
               new AbstractParsing.Common.ParserEdge<_>(4,5,lbl <| RNGLR.ParseCalc.NUMBER 4)
               new AbstractParsing.Common.ParserEdge<_>(3,6,lbl <| RNGLR.ParseCalc.DIV 5)
               new AbstractParsing.Common.ParserEdge<_>(6,5,lbl <| RNGLR.ParseCalc.PLUS 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Pass()
          | Yard.Generators.RNGLR.Parser.Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Fail "!!!!"
      
      [<Test>]
      member this.``Pretty Simple Calc. Error Handling Temp.`` () =
          let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               new AbstractParsing.Common.ParserEdge<_>(0,1,lbl <| RNGLR.PrettySimpleCalc.NUM 1)
               new AbstractParsing.Common.ParserEdge<_>(1,2,lbl <| RNGLR.PrettySimpleCalc.PLUS 2)
               new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.PrettySimpleCalc.NUM 3)
               new AbstractParsing.Common.ParserEdge<_>(3,4,lbl <| RNGLR.PrettySimpleCalc.PLUS 4)
               new AbstractParsing.Common.ParserEdge<_>(4,5,lbl <| RNGLR.PrettySimpleCalc.NUM 5)
               new AbstractParsing.Common.ParserEdge<_>(5,6,lbl <| RNGLR.PrettySimpleCalc.RNGLR_EOF 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | Yard.Generators.RNGLR.Parser.Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.PrettySimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass() 
  
      [<Test>]
      member this.``Pretty Simple Calc. Error Is Not Handled Without EOF.`` () =
          let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               new AbstractParsing.Common.ParserEdge<_>(0,1,lbl <| RNGLR.PrettySimpleCalc.NUM 1)
               new AbstractParsing.Common.ParserEdge<_>(1,2,lbl <| RNGLR.PrettySimpleCalc.PLUS 2)
               new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.PrettySimpleCalc.NUM 3)
               new AbstractParsing.Common.ParserEdge<_>(1,3,lbl <| RNGLR.PrettySimpleCalc.PLUS 4)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | Yard.Generators.RNGLR.Parser.Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.PrettySimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass() 
  
      [<Test>]
      member this.``Pretty Simple Calc. Error Is Handled With EOF.`` () =
          let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               new AbstractParsing.Common.ParserEdge<_>(0,1,lbl <| RNGLR.PrettySimpleCalc.NUM 1)
               new AbstractParsing.Common.ParserEdge<_>(1,2,lbl <| RNGLR.PrettySimpleCalc.PLUS 2)
               new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.PrettySimpleCalc.NUM 3)
               new AbstractParsing.Common.ParserEdge<_>(1,3,lbl <| RNGLR.PrettySimpleCalc.PLUS 4)
               new AbstractParsing.Common.ParserEdge<_>(1,3,lbl <| RNGLR.PrettySimpleCalc.RNGLR_EOF 5)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Pass()
          | Yard.Generators.RNGLR.Parser.Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.PrettySimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Fail "!!!!" 
  
      [<Test>]
      member this.``Calc. Branched input 2.`` () =
          let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [new AbstractParsing.Common.ParserEdge<_>(0,1,lbl <| RNGLR.ParseCalc.NUMBER  1)
               new AbstractParsing.Common.ParserEdge<_>(1,2,lbl <| RNGLR.ParseCalc.PLUS 0)
               new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.ParseCalc.NUMBER 2)
               new AbstractParsing.Common.ParserEdge<_>(3,4,lbl <| RNGLR.ParseCalc.MULT 3)
               new AbstractParsing.Common.ParserEdge<_>(4,5,lbl <| RNGLR.ParseCalc.NUMBER 4)
               new AbstractParsing.Common.ParserEdge<_>(3,6,lbl <| RNGLR.ParseCalc.MINUS 5)
               new AbstractParsing.Common.ParserEdge<_>(6,5,lbl <| RNGLR.ParseCalc.NUMBER 6)
               new AbstractParsing.Common.ParserEdge<_>(5,7,lbl <| RNGLR.ParseCalc.MULT 3)
               new AbstractParsing.Common.ParserEdge<_>(7,8,lbl <| RNGLR.ParseCalc.NUMBER 4)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Yard.Generators.RNGLR.Parser.Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
negative.code:     let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
      printfn "%A" r
      match r with
      | Error (_, tok, message, debug, _) ->
          printfn "Errors in file %s on Tokens %A: %s" inputFilePath tok message
          debug.drawGSSDot "out.dot"
          if shouldContainsSuccess
          then Assert.Fail(sprintf "Test %s should produce sucess parsing result but its fully failed." inputFilePath)
          else Assert.AreEqual(errorsCount, tok.Length, "Errors count mismatch.")
      | Success(tree, tok, _) ->
          tree.PrintAst()
          RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
          if shouldContainsSuccess
  