anchor.diff:                           for level in slotLevels.Value do
                               let resTree = structures.GetNodeP findSppfNode findSppfPackedNode structures.Dummy (u.NontermLabel*1<labelMeasure>) sppfNodeOnEdge z 
                               let newVertex = new Vertex(level, slot)
  -                            structures.AddContext setU i (u.NontermLabel*1<labelMeasure>) newVertex resTree
  +                            structures.AddContext setU i (u.NontermLabel*1<labelMeasure>) newVertex resTree !currentPath
   
           let table = parser.Table
           
           let condition = ref false 
           let stop = ref false
   
  -        let containsError index label vertex ast = 
  +        let containsError index label vertex ast currentPath = 
               let key = pack index label 
               let c, d = errors.TryGetValue(key)
               if c then
                   let c1, d1 = d.TryGetValue(ast)
  -                if c1 then true
  -                else
  -                    d.Add(ast, vertex)
  -                    false
  -            else
  -                let d = new Dictionary<int<nodeMeasure>, Vertex>()
  +                if not c1 
  +                then 
  +                    errorPaths.Add currentPath
  +                    d.Add(ast, (vertex, (errorPaths.Count - 1)))
  +                
  +            else
  +                let d = new Dictionary<int<nodeMeasure>, Vertex*int>()
  +                errorPaths.Add currentPath
  +                d.Add(ast, (vertex, (errorPaths.Count - 1)))
                   errors.Add(key, d)
  -                false
  -
               
   
           let rec dispatcher () =
  
positive.code:             Error ("This grammar does not accept empty input.")     
      else
          let slots = parser.Slots
          let errors = new Dictionary<int64, Dictionary<int<nodeMeasure>, Vertex>>()   
          let setU = Array.zeroCreate<Dictionary<int, Dictionary<int64, ResizeArray<int<nodeMeasure>>>>> (input.VertexCount )///1
          let structures = new ParserStructures(input.VertexCount, parser.StartRule)
          let setR = structures.SetR
  
negative.code:                         | Some edge ->
                              snd edge.Tag := true
                              let curToken = parser.TokenToNumber (fst edge.Tag)
                              currentPath := edge.Target :: currentPath.Value
                              if !structures.CurrentN = structures.Dummy
                              then 
                                  structures.CurrentN := getNodeT edge
  