anchor.diff:                  let cur = nonTerminalNodes.[nTerm]
                   if  cur <> Unchecked.defaultof<_> //<Dictionary<int64<extension>, int<nodeMeasure>>>
                   then
  -                        let contains , d1 = cur.TryGetValue(lExt)
  +                        let contains , d1 = cur.TryGetValue(getLeftExtension ext)
                           if contains
                           then
  -                            let contains, d2 = d1.TryGetValue(rExt)
  +                            let contains, d2 = d1.TryGetValue(getRightExtension ext)
                               if contains
                               then
                                   d2
                               else
  -                                let newNode = new NonTerminalNode(nTerm, packExtension lExt rExt)
  +                                let newNode = new NonTerminalNode(nTerm, ext)
                                   sppfNodes.Add(newNode)
                                   let num = (sppfNodes.Count - 1)*1<nodeMeasure>
  -                                d1.Add(rExt, num)
  +                                d1.Add(getRightExtension ext, num)
                                   num
                           else
                               let d2 = new Dictionary<int, int<nodeMeasure>>()
                               //let d1 = new Dictionary<int, Dictionary<int, int<nodeMeasure>>>()
  -                            let newNode = new NonTerminalNode(nTerm, packExtension lExt rExt)
  +                            let newNode = new NonTerminalNode(nTerm, ext)
                               sppfNodes.Add(newNode)
                               let num = (sppfNodes.Count - 1)*1<nodeMeasure>
  -                            d2.Add(rExt, num)
  -                            cur.Add(lExt, d2)
  +                            d2.Add(getRightExtension ext, num)
  +                            cur.Add(getLeftExtension ext, d2)
                               num
                           
                   else
                       //let d = new Dictionary<int64<extension>, int<nodeMeasure>>()
                       let d2 = new Dictionary<int, int<nodeMeasure>>()
                       let d1 = new Dictionary<int, Dictionary<int, int<nodeMeasure>>>()
  -                    let newNode = new NonTerminalNode(nTerm, packExtension lExt rExt)
  +                    let newNode = new NonTerminalNode(nTerm, ext)
                       sppfNodes.Add(newNode)
                       let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                       //d.Add(ext, num)
  -                    d2.Add(rExt, num)
  -                    d1.Add(lExt, d2)
  +                    d2.Add(getRightExtension ext, num)
  +                    d1.Add(getLeftExtension ext, d2)
                        
                       nonTerminalNodes.[nTerm] <- d1 
                       num
               else
  -                let contains, d1 = intermidiateNodes.TryGetValue lExt
  +                let contains, d1 = intermidiateNodes.TryGetValue ext
                   if contains
                   then
  -                    let contains, d2 = d1.TryGetValue rExt
  +                    let contains, d2 = d1.TryGetValue label
                       if contains
                       then
  -                        let contains, d3 = d2.TryGetValue(label)
  -                        if contains
  -                        then
  -                            d3
  -                        else
  -                            let newNode = new IntermidiateNode(int label, packExtension lExt rExt)
  -                            sppfNodes.Add(newNode)
  -                            let num = (sppfNodes.Count - 1)*1<nodeMeasure>
  -                            d2.Add(label, num)
  -                            num
  -
  +                        d2
                       else
  -                        let d2 = new Dictionary<int<labelMeasure>, int<nodeMeasure>>()
  -                        let newNode = new IntermidiateNode(int label, packExtension lExt rExt)
  +                        let newNode = new IntermidiateNode(int label, ext)
                           sppfNodes.Add(newNode)
                           let num = (sppfNodes.Count - 1)*1<nodeMeasure>
  -                        d2.Add(label, num)
  -                        d1.Add(rExt,d2)
  +                        d1.Add(label, num)
                           num  
                   else
  -                    let d1 = new Dictionary<int, Dictionary<int<labelMeasure>, int<nodeMeasure>>>()
  -                    let d2 = new Dictionary<int<labelMeasure>, int<nodeMeasure>>()
  -                    let newNode = new IntermidiateNode(int label, packExtension lExt rExt)
  +                    let d = new Dictionary<int<labelMeasure>, int<nodeMeasure>>()
  +                    let newNode = new IntermidiateNode(int label, ext)
                       sppfNodes.Add(newNode)
                       let num = (sppfNodes.Count - 1)*1<nodeMeasure>
  -                    d2.Add(label, num)
  -                    d1.Add(rExt, d2)
  -                    intermidiateNodes.Add(lExt, d1)
  +                    d.Add(label, num)
  +                    intermidiateNodes.Add(ext, d)
                       num
   
           let findSppfPackedNode symbolNode label leftExtension rightExtension (left : INode) (right : INode) : int<nodeMeasure> = 
  
positive.code:     val lbl: int<labelMeasure>
      val node: int<nodeMeasure>
      new (l,n) = {lbl=l; node=n}
  
  
  let buildAst<'TokenType> (parser : ParserSourceGLL<'TokenType>) (tokens : seq<'TokenType>) : ParseResult<_>  = 
      let tokens = seq {yield! tokens; yield parser.EOF}
  
negative.code:             | Some res -> 
                      let r1 = new Tree<_> (tokens, res, parser.rules)
                      let path = @"../../../src/GLLApplication/out.txt"
  //                    let out = new System.IO.StreamWriter (path) 
  //                    out.WriteLine("packed nodes read count = " + (!packedNodesReadCount).ToString())
  //                    out.WriteLine("packed nodes write count = " + (!packedNodesWriteCount).ToString()) 
  