anchor.diff:          // Find the 'y' values related to 'x' and compute xRy
           // by recursively traversing them.
           let F, N, stack =
  -            ((F, N, stack), Map.find x R)
  -            ||> Set.fold (fun (F, N, stack) y ->
  -                let F, N, stack =
  -                    if Map.containsKey y N then
  -                        F, N, stack
  -                    else
  -                        traverse (y, N, stack, F, X, R, F')
  -
  -                let N =
  -                    let ``N(x)`` = Map.find x N
  -                    let ``N(y)`` = Map.find y N
  -                    Map.add x (min ``N(x)`` ``N(y)``) N
  -
  -                let F =
  -                    match Map.tryFind y F with
  -                    | None -> F
  -                    | Some ``F(y)`` ->
  -                        let ``F(x)`` = Map.find x F
  -                        Map.add x (Set.union ``F(x)`` ``F(y)``) F
  -
  -                F, N, stack)
  +            match Map.tryFind x R with
  +            | None ->
  +                F, N, stack
  +            | Some ``R(x)`` ->
  +                ((F, N, stack), ``R(x)``)
  +                ||> Set.fold (fun (F, N, stack) y ->
  +                    let F, N, stack =
  +                        match Map.find y N with
  +                        | Untraversed ->
  +                            traverse (y, N, stack, F, X, R, F')
  +                        | _ ->
  +                            F, N, stack
  +
  +                    let N =
  +                        let ``N(x)`` = Map.find x N
  +                        let ``N(y)`` = Map.find y N
  +                        Map.add x (min ``N(x)`` ``N(y)``) N
  +
  +                    let F =
  +                        match Map.tryFind y F with
  +                        | None -> F
  +                        | Some ``F(y)`` ->
  +                            let ``F(x)`` = Map.find x F
  +                            Map.add x (Set.union ``F(x)`` ``F(y)``) F
  +
  +                    F, N, stack)
   
           // Walk back up the stack, if necessary.
           match Map.find x N with
  
positive.code: 
          ((Map.empty, N, []), X)
          ||> Set.fold (fun (F, N, stack) x ->
              if Map.containsKey x N then
                  F, N, stack
              else
                  traverse (x, N, stack, F, X, R, F'))
          // Discard the intermediate variables
          |> fun (F, N, _) ->
              // DEBUG : Make sure all set elements have been completely traversed.
              Debug.Assert (
                  Set.forall (fun x -> match Map.find x N with Traversed -> true | _ -> false) X,
                  "Some elements of X have not been completely traversed.")
  
              // Return the computed relation.
              F
  
negative.code:         // by inspection of the transition's successor state.
          let directRead = directRead lr0ParserTable
  
          // C. Compute 'reads'. One set of nonterminal transitions per nonterminal transition,
          // by inspection of the successor state of the later transition.
          let reads =
              (Map.empty, lr0ParserTable.GotoTable)
              ||> Map.fold (fun reads transition succStateId ->
                  (reads, lr0ParserTable.GotoTable)
                  ||> Map.fold (fun reads ((stateId, nonterminal) as succTransition) _ ->
                      // We only care about successors of the original transition;
                      // also, the nonterminal for this (successor) transition must be nullable.
                      if stateId = succStateId &&
                          Map.find nonterminal nullable then
                          // Add the edge to the adjacency map representing the induced 'reads' graph.
                          let readsTransition =
                              match Map.tryFind transition reads with
                              | None ->
                                  Set.singleton succTransition
                              | Some readsTransition ->
                                  Set.add succTransition readsTransition
  
                          Map.add transition readsTransition reads
                      else
                          reads))
  
          //
          digraph nonterminalTransitions reads directRead
  
      //
      let private lookbackAndIncludes (grammar : AugmentedGrammar<'Nonterminal, 'Terminal>, lr0ParserTable : Lr0ParserTable<'Nonterminal, 'Terminal>, nonterminalTransitions, nullable) =
  