anchor.diff:                  | _ -> ()
                   num
                     
  -        let getNodeT (edge : ParserEdge<'TokenType*ref<bool>>) =
  +        let getNodeT (edge : ParserEdge<'TokenType>) =
               let beginVertix = edge.Source
               let endVertix = edge.Target
               let tag = edge.Tag
  -            let i = (parser.TokenToNumber (fst tag)) - parser.NonTermCount
  +            let i = (parser.TokenToNumber ( tag)) - parser.NonTermCount
               if terminalNodes.[beginVertix, endVertix, i] <> Unchecked.defaultof<int<nodeMeasure>>
               then
                   terminalNodes.[beginVertix, endVertix, i]
               else
  -                tokens.Add (fst tag)
  +                tokens.Add ( tag)
                   let t = new TerminalNode(tokens.Length - 1, packExtension beginVertix endVertix)
                   sppfNodes.Add t
                   let res = sppfNodes.Length - 1
  
positive.code:                             res
                          match curEdge with
                          | Some edge ->
                              snd edge.Tag := true
                              let curToken = parser.TokenToNumber (fst edge.Tag)
                              //currentPath := edge :: currentPath.Value
                              if !structures.CurrentN = structures.Dummy
                              then 
  
negative.code:     new (p,l) = {pos = p; lbl = l}
  
  let buildAbstractAst<'TokenType> (parser : ParserSourceGLL<'TokenType>) (input : ParserInputGraph<'TokenType>) : ParserCommon.ParseResult<_> = 
      (*let input = input
      let input = 
          let h = input.Edges |> Seq.map (fun e -> new ParserEdge<'TokenType * ref<bool>>(e.Source, e.Target, (e.Tag , ref false)))
          let g = new ParserInputGraph<'TokenType * ref<bool>>((input.InitStates : int[]), (input.FinalStates : int[]))
          g*)
      
      if input.EdgeCount = 0 then
        //  if parser.AcceptEmptyInput then
  