anchor.diff:  
       [<Test>]
       member this.``Simple calc. Branch binop and second arg.`` () =
  -        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<_>(1,3,lbl <| RNGLR.ParseSimpleCalc.PLUS 3)
  -             new AbstractParsing.Common.ParserEdge<_>(2,4,lbl <| RNGLR.ParseSimpleCalc.NUM 2)
  -             new AbstractParsing.Common.ParserEdge<_>(3,4,lbl <| RNGLR.ParseSimpleCalc.NUM 4)
  +        let qGraph = new ParserInputGraph<_>()
  +        qGraph.AddVertexRange[0;1;2;3] |> ignore
  +        qGraph.AddVerticesAndEdgeRange
  +            [edg 0 1 (RNGLR.ParseSimpleCalc.NUM 1)
  +             edg 1 2 (RNGLR.ParseSimpleCalc.PLUS 0)
  +             edg 1 3 (RNGLR.ParseSimpleCalc.PLUS 3)
  +             edg 2 4 (RNGLR.ParseSimpleCalc.NUM 2)
  +             edg 3 4 (RNGLR.ParseSimpleCalc.NUM 4)
                ] |> 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, _, _) ->
  +        | Error (num, tok, message, debug, _) ->
  +            printfn "Error in position %d on Token %A: %s" num tok message
  +            debug.drawGSSDot "out.dot"
  +            Assert.Fail "!!!!!!"
  +        | Success(tree, _, _) ->
               tree.PrintAst()
               RNGLR.ParseSimpleCalc.defaultAstToDot tree "ast.dot"
               Assert.Pass()
   
       [<Test>]
       member this.``Simple calc. Branch binop and first arg.`` () =
  -        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<_>(0,2,lbl <| RNGLR.ParseSimpleCalc.NUM 2)
  -             new AbstractParsing.Common.ParserEdge<_>(1,3,lbl <| RNGLR.ParseSimpleCalc.PLUS 3)
  -             new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.ParseSimpleCalc.PLUS 4)
  -             new AbstractParsing.Common.ParserEdge<_>(3,4,lbl <| RNGLR.ParseSimpleCalc.NUM 5)
  +        let qGraph = new ParserInputGraph<_>()
  +        qGraph.AddVertexRange[0;1;2;3] |> ignore
  +        qGraph.AddVerticesAndEdgeRange
  +            [edg 0 1 (RNGLR.ParseSimpleCalc.NUM 1)
  +             edg 0 2 (RNGLR.ParseSimpleCalc.NUM 2)
  +             edg 1 3 (RNGLR.ParseSimpleCalc.PLUS 3)
  +             edg 2 3 (RNGLR.ParseSimpleCalc.PLUS 4)
  +             edg 3 4 (RNGLR.ParseSimpleCalc.NUM 5)
                ] |> 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, _, _) ->
  +        | Error (num, tok, message, debug, _) ->
  +            printfn "Error in position %d on Token %A: %s" num tok message
  +            debug.drawGSSDot "out.dot"
  +            Assert.Fail "!!!!!!"
  +        | Success(tree, _, _) ->
               tree.PrintAst()
               RNGLR.ParseSimpleCalc.defaultAstToDot tree "ast.dot"
               Assert.Pass()
   
       [<Test>]
       member this.``Simple calc with nterm. Seq input.`` () =
  -        let qGraph = new AbstractParsing.Common.ParserInputGraph<_>()
  -        qGraph.AddVertexRange[0;1;2;3] |> ignore
  -        qGraph.AddVerticesAndEdgeRange
  -            [new AbstractParsing.Common.ParserEdge<_>(0,1,lbl <| RNGLR.SimpleCalcWithNTerm.NUM 1)
  -             new AbstractParsing.Common.ParserEdge<_>(1,2,lbl <| RNGLR.SimpleCalcWithNTerm.PLUS 0)
  -             new AbstractParsing.Common.ParserEdge<_>(2,3,lbl <| RNGLR.SimpleCalcWithNTerm.NUM 2)
  +        let qGraph = new ParserInputGraph<_>()
  +        qGraph.AddVertexRange[0;1;2;3] |> ignore
  +        qGraph.AddVerticesAndEdgeRange
  +            [edg 0 1 (RNGLR.SimpleCalcWithNTerm.NUM 1)
  +             edg 1 2 (RNGLR.SimpleCalcWithNTerm.PLUS 0)
  +             edg 2 3 (RNGLR.SimpleCalcWithNTerm.NUM 2)
                ] |> ignore
   
           let r = (new Parser<_>()).Parse  RNGLR.SimpleCalcWithNTerm.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, _, _) ->
  +        | Error (num, tok, message, debug, _) ->
  +            printfn "Error in position %d on Token %A: %s" num tok message
  +            debug.drawGSSDot "out.dot"
  +            Assert.Fail "!!!!!!"
  +        | Success(tree, _, _) ->
               tree.PrintAst()
               RNGLR.SimpleCalcWithNTerm.defaultAstToDot tree "ast.dot"
               Assert.Pass()
  
positive.code: //    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)))
  //    lexerInputG
  
  
  
  
  let lbl tokenId = tokenId
  
  let loadLexerInputGraph gFile =
      let qGraph = loadDotToQG gFile
  
negative.code: 
      [<Test>]
      member this.``Simple calc. Sequence input.`` () =
          let qGraph = new ParserInputGraph<_>()        
          qGraph.AddVerticesAndEdgeRange
              [edg 0 1 (RNGLR.ParseSimpleCalc.NUM 1)
               edg 1 2 (RNGLR.ParseSimpleCalc.PLUS 0)
               edg 2 3 (RNGLR.ParseSimpleCalc.NUM 2)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseSimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseSimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Sequence input.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [edg 0 1 (RNGLR.ParseCalc.NUMBER  1)
               edg 1 2 (RNGLR.ParseCalc.PLUS 0)
               edg 2 3 (RNGLR.ParseCalc.NUMBER 2)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Success(tree, _ ,_) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Branched input.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [edg 0 1 (RNGLR.ParseCalc.NUMBER  1)
               edg 1 2 (RNGLR.ParseCalc.PLUS 0)
               edg 2 3 (RNGLR.ParseCalc.NUMBER 2)
               edg 3 4 (RNGLR.ParseCalc.MULT 3)
               edg 4 5 (RNGLR.ParseCalc.NUMBER 4)
               edg 3 6 (RNGLR.ParseCalc.DIV 5)
               edg 6 5 (RNGLR.ParseCalc.NUMBER 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Branched input error.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               edg 0 3 (RNGLR.ParseCalc.NUMBER 2)
               edg 3 4 (RNGLR.ParseCalc.MULT 3)
               edg 4 5 (RNGLR.ParseCalc.NUMBER 4)
               edg 3 6 (RNGLR.ParseCalc.DIV 5)
               edg 6 5 (RNGLR.ParseCalc.PLUS 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Pass()
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Fail "This test should "
      
      [<Test>]
      member this.``Pretty Simple Calc. Error Handling Temp.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               edg 0 1 (RNGLR.PrettySimpleCalc.NUM 1)
               edg 1 2 (RNGLR.PrettySimpleCalc.PLUS 2)
               edg 2 3 (RNGLR.PrettySimpleCalc.NUM 3)
               edg 3 4 (RNGLR.PrettySimpleCalc.PLUS 4)
               edg 4 5 (RNGLR.PrettySimpleCalc.NUM 5)
               edg 5 6 (RNGLR.PrettySimpleCalc.RNGLR_EOF 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | 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 ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               edg 0 1 (RNGLR.PrettySimpleCalc.NUM 1)
               edg 1 2 (RNGLR.PrettySimpleCalc.PLUS 2)
               edg 2 3 (RNGLR.PrettySimpleCalc.NUM 3)
               edg 1 3 (RNGLR.PrettySimpleCalc.PLUS 4)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | 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 ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               edg 0 1 (RNGLR.PrettySimpleCalc.NUM 1)
               edg 1 2 (RNGLR.PrettySimpleCalc.PLUS 2)
               edg 2 3 (RNGLR.PrettySimpleCalc.NUM 3)
               edg 1 3 (RNGLR.PrettySimpleCalc.PLUS 4)
               edg 1 3 (RNGLR.PrettySimpleCalc.RNGLR_EOF 5)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Pass()
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.PrettySimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Fail "!!!!" 
  
      [<Test>]
      member this.``Calc. Branched input 2.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [edg 0 1 (RNGLR.ParseCalc.NUMBER  1)
               edg 1 2 (RNGLR.ParseCalc.PLUS 0)
               edg 2 3 (RNGLR.ParseCalc.NUMBER 2)
               edg 3 4 (RNGLR.ParseCalc.MULT 3)
               edg 4 5 (RNGLR.ParseCalc.NUMBER 4)
               edg 3 6 (RNGLR.ParseCalc.MINUS 5)
               edg 6 5 (RNGLR.ParseCalc.NUMBER 6)
               edg 5 7 (RNGLR.ParseCalc.MULT 3)
               edg 7 8 (RNGLR.ParseCalc.NUMBER 4)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  