anchor.diff:                      let unbrowsed = Array.append need <| skipped.ToArray()
                       pushes.Push (fst3 arr.[!var], snd3 arr.[!var])
                       let fam = createErrorFam unbrowsed
  -                    createErrorNode fam <| box tokens.[errInd] <| 0 <| Set.toArray !expected <| thr arr.[!var]
  +                    let rec onTok i =
  +                        if i >= 0
  +                        then
  +                            let x = tokens.[i] 
  +                            if box x <> null
  +                            then box x
  +                            else onTok (i-1)
  +                        else null
  +                            
  +                    createErrorNode fam <| onTok errInd <| 0 <| Set.toArray !expected <| thr arr.[!var]
   
           let errorRuleExist = parserSource.ErrorRulesExists
           let wasError = ref false
   
           while not !isEnd && not !wasError do
               if usedStates.Count = 0 && reductions.Count = 0
  -            then wasError := true
  +            then 
  +                wasError := true
               else
  -                makeReductions !curInd
  +                makeReductions !curInd recovery
                   attachEdges()
                   if !curNum = parserSource.EofIndex then isEnd := true
                   elif pushes.Count = 0 then 
  
positive.code:                 //if parser finished in the non-accepting state and it generates the recovery
                  pushes.Clear()
  
                  while curVertices.Value.Count <> 0 && not <| containsRecState !curVertices temp recVertNumber do
                      curVertices := getPrevVertices !curVertices
                  
                  let skipped = Queue<_>()
  
negative.code:                         for (prod, pos) in arr do
                              let edgeOpt = Some (vertex.OutEdges.first.Dest, vertex.OutEdges.first.Ast)
                              reductions.Push (vertex, prod, pos, edgeOpt)
                          makeReductions !curInd recovery
                          temp.Enqueue path
                      //if shift is possible
                      let push = parserSource.Gotos.[vertex.State].[!curNum]
  