anchor.diff:                          {
                               parserState with 
                                   statesSet = 
  -                                    parserState.statesSet
  +                                    parserState.statesSet                                    
                                       |> Set.map (fun stt -> {stt with forest = leaf stt; sTrace=[]})
                                   inpSymbol = nextLexeme
                                   i         = parserState.i + 1
  
positive.code:                                     |> List.length = 1
                                      |> getTrace itm.state parserState.inpSymbol.name itm.state.position res.rItem.position
                                      |> fun x -> x @ res.rItem.sTrace
                                  if itm.state.position <> dfa.DStartState
                                  then
                                      parserState.statesSet
                                      |> Set.map
                                          (fun state ->
                                              {
                                                  rItem  = {itm.state with
                                                              forest = state.forest @ res.rItem.forest
                                                              sTrace = trace state
                                                           }
                                                  rI     = res.rI
                                              })
                                  else
                                      ({
                                          parserState with
                                              inpSymbol = {name = res.rItem.itemName; value = ""} 
                                              i         = res.rI
                                              statesSet =
                                                  parserState.statesSet
                                                  |> Set.map
                                                      (fun stt ->
                                                          {stt with forest = [stt.forest @ res.rItem.forest |> node (trace stt)]
                                                                    sTrace = []
                                                          })
                                      }
                                      |> fun ps ->
                                          if itm.state.itemName = Constants.raccStartRuleName
                                          then
                                              if ((!Lexer).Value.Get ps.i).name = "EOF"
                                              then buildRes ((ps.statesSet.MaximumElement)|>Set.singleton)
                                              else Set.empty
                                          else climb () ps)
                                  |> Set.union  buf
                              )
                              Set.empty)
  
negative.code:                             else buf
                      else buf)
                  Set.empty
  //#if DEBUG
          Set.iter PrintTree res
  //#endif
          cache.Clear()
          traceBuilderCache.Clear()
          let trC =
  