anchor.diff:          (* _fsyacc_stateToProdIdxsTableElements *)
           (* _fsyacc_stateToProdIdxsTableRowOffsets *)
           let _fsyacc_stateToProdIdxsTableElements, _fsyacc_stateToProdIdxsTableRowOffsets =
  -            // TEST : Need to modify Graham.LR.LrParserTable to provide the production rules
  -            // of the _augmented_ grammar before this can be correctly implemented.
  -            let productionRuleIndices : Map<_, int> =
  -                raise <| System.NotImplementedException ()
  -                Map.empty
  +            // OPTIMIZE : Modify Graham.LR.LrParserTable to provide the production rules
  +            // of the _augmented_ grammar instead of re-augmenting them here.
  +            let productionRuleIndices : Map<AugmentedNonterminal<_> * AugmentedSymbol<_,_>[], int> =
  +                let productionRuleIndices =
  +                    (Map.empty, processedSpec.StartSymbols)
  +                    ||> Set.fold (fun productionRuleIndices startSymbol ->
  +                        let key =
  +                            AugmentedNonterminal.Start,
  +                            [| Symbol.Nonterminal <| AugmentedNonterminal.Nonterminal startSymbol; Symbol.Terminal EndOfFile |]
  +                        Map.add key productionRuleIndices.Count productionRuleIndices)
  +
  +                // Add the rest of the production rules.
  +                (productionRuleIndices, processedSpec.ProductionRules)
  +                ||> Map.fold (fun productionRuleIndices nonterminal rules ->
  +                    (productionRuleIndices, rules)
  +                    ||> Array.fold (fun productionRuleIndices rule ->
  +                        let key =
  +                            let symbols =
  +                                rule.Symbols
  +                                |> Array.map (function
  +                                    | Symbol.Nonterminal nonterminal ->
  +                                        AugmentedNonterminal.Nonterminal nonterminal
  +                                        |> Symbol.Nonterminal
  +                                    | Symbol.Terminal terminal ->
  +                                        AugmentedTerminal.Terminal terminal
  +                                        |> Symbol.Terminal)
  +
  +                            AugmentedNonterminal.Nonterminal nonterminal, symbols
  +
  +                        Map.add key productionRuleIndices.Count productionRuleIndices))
   
               let parserStates =
                   Map.toArray parserTable.ParserStates
  
positive.code:             parserTable.ParserStates
              |> Map.iter (fun parserStateId items ->
                  // Set the array element corresponding to this parser state.
                  immediateActions.[int parserStateId - 1] <-
                      // Does this state contain just one (1) item?
                      if Set.count items <> 1 then
                          // Return the value which indicates this parser state has no immediate action.
  
negative.code:             ActionValue.Shift |||
              EnumOfValue (Checked.uint16 targetStateId)
  
      //
      type private FsyaccNonterminal<'Nonterminal when 'Nonterminal : comparison> =
          //
          | Start of 'Nonterminal
          //
          | Nonterminal of 'Nonterminal
  
      //
      type private FsyaccTerminal<'Terminal when 'Terminal : comparison> =
          //
          | Terminal of 'Terminal
          //
          | Error
  
      // TEMP : Only needed until we modify Graham.LR.LrParserTable to provide the
      // production rules of the _augmented_ grammar.
      let private deaugmentSymbols (symbols : AugmentedSymbol<'Nonterminal, 'Terminal>[]) =
          symbols
          |> Array.map (function
              | Symbol.Nonterminal nonterminal ->
                  match nonterminal with
                  | AugmentedNonterminal.Start ->
                      failwith "Start symbol in an item which is not part of the start production."
                  | AugmentedNonterminal.Nonterminal nonterminal ->
                      Symbol.Nonterminal nonterminal
              | Symbol.Terminal terminal ->
                  match terminal with
                  | EndOfFile ->
                      failwith "Unexpected end-of-file symbol."
                  | AugmentedTerminal.Terminal terminal ->
                      Symbol.Terminal terminal)
  
      /// Emit a formatted string as a single-line F# comment into an IndentedTextWriter.
      let inline private comment (writer : IndentedTextWriter) fmt : ^T =
  