anchor.diff:      member this.``Test with position. Ident on edgs with branch in begin_1.`` () =
           let lexerInputGraph = loadLexerInputGraph "test_with_pos_5.dot"
           let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 3)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 3)
  -        let positons =
  +        checkGraph res 3 3
  +        let positions =
               res.Edges 
                 |> Seq.collect
                     (fun e -> 
  
positive.code:         let lexerInputG = new LexerInputGraph<_>()
          lexerInputG.StartVertex <- 0
          for e in qGraph.Edges do lexerInputG.AddEdgeForsed (new LexerEdge<_,_>(e.Source,e.Target,Some(e.Tag, e.Tag)))
          Assert.AreEqual(lexerInputG.Edges |> Seq.length, 4)
          Assert.AreEqual(lexerInputG.Vertices |> Seq.length, 4)
  
      [<Test>]
      member this.``Load graph test from DOT to lexer inner graph`` () =
          let lexerInnerGraph = new LexerInnerGraph<_>(loadLexerInputGraph "test_00.dot")
          Assert.AreEqual(lexerInnerGraph.StartVertex, 0)
          Assert.AreEqual(lexerInnerGraph.Edges |> Seq.length, 6)
          Assert.AreEqual(lexerInnerGraph.Vertices |> Seq.length, 6)
  
      [<Test>]
      member this.``Calc. Simple number.`` () =
          let lexerInputGraph = loadLexerInputGraph "test_0.dot"
          let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
          Assert.AreEqual(res.Edges |> Seq.length, 2)
          Assert.AreEqual(res.Vertices |> Seq.length, 3)
  
      [<Test>]
      member this.``Test with position.`` () =
          let lexerInputGraph = loadLexerInputGraph "test_with_pos_0.dot"
          let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
          Assert.AreEqual(res.Edges |> Seq.length, 2)
          Assert.AreEqual(res.Vertices |> Seq.length, 3)
          res.Edges 
            |> Seq.iter
                (fun e -> 
                  match e.Tag with
                  | NUMBER (n,brs)->
                      Assert.AreEqual(brs.Length,n.Length)
                      //Assert.IsTrue(brs |> Array.forall (fun x -> x.back_ref |> Option.isSome))
                      let brs' = brs |> Array.map (fun i -> i.back_ref)
                      Assert.IsTrue(brs'.[0] = "12|")
                      Assert.IsTrue(brs'.[1] = "12|")
                      let pos' = brs |> Array.map (fun i -> i.pos_cnum)
                      Assert.IsTrue(pos'.[0] = 0)
                      Assert.IsTrue(pos'.[1] = 1)
                  | RNGLR_EOF _ -> ()
                  | t -> Assert.Fail(sprintf "Unexpected token: %A" t)) 
  
      [<Test>]
      member this.``Test with position. Ident on two edgs`` () =
          let lexerInputGraph = loadLexerInputGraph "test_with_pos_1.dot"
          let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
          Assert.AreEqual(res.Edges |> Seq.length, 2)
          Assert.AreEqual(res.Vertices |> Seq.length, 3)
          res.Edges 
            |> Seq.iter
                (fun e -> 
                  match e.Tag with
                  | NUMBER (n,brs)->
                      Assert.AreEqual(brs.Length,n.Length)
                      //Assert.IsTrue(brs |> Array.forall (fun x -> x.back_ref |> Option.isSome))
                      let brs' = brs |> Array.map (fun i -> i.back_ref)
                      Assert.IsTrue(brs'.[0] = "12|")
                      Assert.IsTrue(brs'.[1] = "12|")
                      Assert.IsTrue(brs'.[2] = "3|")
                      let pos' = brs |> Array.map (fun i -> i.pos_cnum)
                      Assert.IsTrue(pos'.[0] = 0)
                      Assert.IsTrue(pos'.[1] = 1)
                      Assert.IsTrue(pos'.[2] = 0)
                  | RNGLR_EOF _ -> ()
                  | t -> Assert.Fail(sprintf "Unexpected token: %A" t)) 
  
  
negative.code:     member this.``Test with position. Ident and plus on edgs with branch`` () =
          let lexerInputGraph = loadLexerInputGraph "test_with_pos_3.dot"
          let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
          checkGraph res 4 4
          printG res "test_with_pos_3_res"
          let positions =
              res.Edges 
                |> Seq.collect
                    (fun e -> 
  