anchor.diff:                                                           item.forest @ frst
                                                           ,item.itemName
                                                           ,{
  -                                                        id    = item.itemName
  -                                                        trace = []
  -                                                        value = NodeV 0 
  -                                                        }
  +                                                            id    = item.itemName
  +                                                            trace = []
  +                                                            value = NodeV 0 
  +                                                         }
                                                         )
                                                   ]
                                               let d = Set.maxElement res
  
positive.code:                                         }
                                          )]
                              let climbRes = 
                                  let fl = Set.filter (isFinaleState >> not) parserState.statesSet
                                  (climb()) 
                                      tables 
                                          {
  
negative.code:                             parserState.statesSet
                      else
                          let parserResult = (parse()) tables {parserState with statesSet = gotoSet}                          
                          let resPart1 =  
                              Set.fold
                                  (fun buf res ->
                                      if res.rItem.position > 0
                                      then
                                          let prevItems = getPrevItems tables parserState.inpSymbol.name res.rItem
                                          Set.fold 
                                              (fun buf itm -> 
                                                  if itm.state.position>0
                                                  then 
                                                      Set.add
                                                          {
                                                              rItem      = prevItems.MaximumElement.state
                                                              rInpStream = parserState.inpStream
                                                              rLexer     = parserState.lexer
                                                          }
                                                          buf  
                                                  else
                                                      buf)
                                              buf
                                              prevItems
                                                                                                                                                                    
                                      else
                                          buf)
                                  Set.empty
                                  parserResult                      
                              (*let possibleStates = 
                                  Set.map (getItems tables parserState.inpSymbol.name) parserState.statesSet  
                                  |> Set.unionMany
                              let resItems =
  