anchor.diff:                  Map.add nonterminal edges gotoEdges)
   
           // _fsyacc_gotos
  -        let _fsyacc_gotos =
  -            let arr = Array.zeroCreate gotoEdges.Count
  -            
  -            //
  -            ((0, 0), gotoEdges)
  -            ||> Map.fold (fun (nonterminalIndex, startIndex) nonterminal edges ->
  +        // _fsyacc_sparseGotoTableRowOffsets
  +        let _fsyacc_gotos, _fsyacc_sparseGotoTableRowOffsets =
  +            let startSymbolCount = Set.count processedSpec.StartSymbols
  +            let gotos = ResizeArray ()
  +            let offsets = Array.zeroCreate (startSymbolCount + gotoEdges.Count)
  +
  +            // Add entries for the "fake" starting nonterminals.
  +            for i = 0 to startSymbolCount - 1 do
  +                gotos.Add 0us
  +                gotos.Add (EnumToValue ActionValue.Any)
  +                offsets.[i] <- uint16 (2 * i)
  +
  +            // Add entries for the rest of the nonterminals.
  +            (startSymbolCount, gotoEdges)
  +            ||> Map.fold (fun nonterminalIndex nonterminal edges ->
                   // Store the starting index (in the sparse GOTO table) for this nonterminal.
  -                arr.[nonterminalIndex] <- uint16 startIndex
  -
  -                // Update the counters
  -                nonterminalIndex + 1,
  -                startIndex + Set.count edges)
  -            // Discard the counters
  +                offsets.[nonterminalIndex] <- Checked.uint16 gotos.Count
  +
  +                // Add the number of edges and the "any" action to the sparse GOTOs table.
  +                gotos.Add (uint16 <| Set.count edges)
  +                gotos.Add (EnumToValue ActionValue.Any)
  +
  +                // Add each of the GOTO edges to the sparse GOTO table.
  +                edges
  +                |> Set.iter (fun (source, target) ->
  +                    gotos.Add <| Checked.uint16 source
  +                    gotos.Add <| Checked.uint16 target)
  +
  +                // Update the nonterminal index for the next iteration.
  +                nonterminalIndex + 1)
  +            // Discard the counter
               |> ignore
   
  -            // Return the constructed array.
  -            arr
  +            // Convert the ResizeArray to an array and return it.
  +            gotos.ToArray (),
  +            offsets
   
           oneLineArrayUInt16 ("_fsyacc_gotos", false,
               _fsyacc_gotos) writer
  -
  -        // _fsyacc_sparseGotoTableRowOffsets
  -        let _fsyacc_sparseGotoTableRowOffsets =
  -            [| |]
  -
           oneLineArrayUInt16 ("_fsyacc_sparseGotoTableRowOffsets", false,
               _fsyacc_sparseGotoTableRowOffsets) writer
   
  
positive.code:                 |> writer.WriteLine)
          writer.WriteLine ()
  
          /// The source and target states of GOTO transitions over each nonterminal.
          let gotoEdges =
              (Map.empty, parserTable.GotoTable)
  
negative.code:     /// The name of the error terminal.
      let [<Literal>] private errorTerminal : TerminalIdentifier = "error"
  
      /// Emits code for an fsyacc-compatible parser into an IndentedTextWriter.
      let emit (processedSpec : ProcessedSpecification<NonterminalIdentifier, TerminalIdentifier>,
                  parserTable : Lr0ParserTable<NonterminalIdentifier, TerminalIdentifier>) (writer : IndentedTextWriter) : unit =
          // TODO : Emit the module declaration
  