anchor.diff:              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
  -            | Nonterminal nonterminal ->
  +            | Symbol.Nonterminal nonterminal ->
                   match nonterminal with
  -                | Start ->
  +                | AugmentedNonterminal.Start ->
                       failwith "Start symbol in an item which is not part of the start production."
                   | AugmentedNonterminal.Nonterminal nonterminal ->
  -                    Nonterminal nonterminal
  -            | Terminal terminal ->
  +                    Symbol.Nonterminal nonterminal
  +            | Symbol.Terminal terminal ->
                   match terminal with
                   | EndOfFile ->
                       failwith "Unexpected end-of-file symbol."
                   | AugmentedTerminal.Terminal terminal ->
  -                    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 =
  
positive.code:                         // Is the parser position at the end of the production rule?
                          // (Or, if it's one of the starting productions -- the next-to-last position).
                          match item.Nonterminal with
                          | Start when int item.Position = (Array.length item.Production - 1) ->
                              // This state should have an immediate Accept action.
                              EnumToValue ActionValue.Accept
  
  
negative.code:         (* _fsyacc_stateToProdIdxsTableElements *)
          (* _fsyacc_stateToProdIdxsTableRowOffsets *)
          let _fsyacc_stateToProdIdxsTableElements, _fsyacc_stateToProdIdxsTableRowOffsets =
              // 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
  