anchor.diff:      | Error of string
   
   
  -let buildAst<'TokenType> (parser : ParserSourceGLL<'TokenType>) (tokens : seq<'TokenType>) : ParseResult<_> = 
  +let buildAst<'TokenType> (parser : ParserSourceGLL<'TokenType>) (tokens : seq<'TokenType>) : ParseResult<_>  = 
  +    let tokens = seq {yield! tokens; yield parser.EOF}
       let tokens = Seq.toArray tokens
       let inputLength = Seq.length tokens
       let nonTermsCountLimit = 1 + (Array.max parser.LeftSide)
  
positive.code:                 currentIndex := currentContext.Value.Index
                  currentGSSNode := currentContext.Value.Vertex
                  currentLabel := currentContext.Value.Label
                  currentN := currentContext.Value.Ast 
                  currentR := dummy
                  condition := false
  
negative.code:         let findSppfNode label lExt rExt : int<nodeMeasure> =
              let isEnd = slotIsEnd label
              let nTerm = parser.LeftSide.[getRule label]
              if isEnd
              then
                  let cur = nonTerminalNodes.[nTerm, lExt, rExt]
                  nonTerminalNodesReadCount := !nonTerminalNodesReadCount + 1
                  if  cur = Unchecked.defaultof<int<nodeMeasure>>
                  then
                      let newNode = new NonTerminalNode(nTerm, (packExtension lExt rExt))
                      sppfNodes.Add(newNode)
                      let num = sppfNodes.Count - 1
                      nonTerminalNodes.[nTerm, lExt, rExt] <- num*1<nodeMeasure>
                      nonterminalNodesX.[nTerm] <- nonterminalNodesX.[nTerm] + 1
                      nonterminalNodesY.[lExt] <- nonterminalNodesY.[lExt] + 1
                      nonterminalNodesZ.[rExt] <- (nonterminalNodesZ.[rExt] + 1)
                      nonTerminalNodesWriteCount := !nonTerminalNodesWriteCount + 1
                      num*1<nodeMeasure>
                  else
                      cur
              else
                  intermidiateNodesReadCount := !intermidiateNodesReadCount + 1 
                  let cur = intermidiateNodes.[lExt, rExt]
                  if cur = Unchecked.defaultof<Dictionary<int<labelMeasure>, int<nodeMeasure>>>
                  then
                      let d = new Dictionary<int<labelMeasure>, int<nodeMeasure>>()
                      let newNode = new IntermidiateNode(int label, (packExtension lExt rExt))
                      sppfNodes.Add(newNode)
                      let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                      d.Add(label, num)
                      intermidiateNodesWriteCount := !intermidiateNodesWriteCount + 1
                      intermidiateNodes.[lExt, rExt] <- d 
                      num
                  else
                      //intermidiateNodesReadCount := !intermidiateNodesReadCount + 1
                      let dict = cur//intermidiateNodes.[lExt, rExt] 
                      if dict.ContainsKey label
                      then
                          dict.[label]
  