anchor.diff:          writer.WriteLine ()
   
           // Emit constants for "end-of-input" and "tag of error terminal"
  -        // TODO
  +        intLiteralDecl ("_fsyacc_endOfInputTag", false,
  +            Map.find endOfInputTerminal tokenTags) writer
  +        intLiteralDecl ("_fsyacc_tagOfErrorTerminal", false,
  +            Map.find errorTerminal tokenTags) writer
  +        writer.WriteLine ()
   
           // Emit the token -> token-name function.
           quickSummary writer "Gets the name of a token as a string."
  
positive.code:                 | Some options ->
                      options
  
              // Generate the code and write it to the specified file.
              using (File.CreateText fsyaccOptions.OutputPath) <| fun streamWriter ->
                  use indentedTextWriter =
  
negative.code:                     sprintf "| %s of (%s)" caseName caseType
                  |> writer.WriteLine)
  
      /// Emits code which declares a literal integer value into a TextWriter.
      let private intLiteralDecl (name, isPublic, value : int) (writer : #TextWriter) =
          // Preconditions
          if System.String.IsNullOrWhiteSpace name then
              invalidArg "name" "The variable name cannot be null/empty/whitespace."
  
          if isPublic then
              sprintf "let [<Literal>] %s = %i" name value
          else
              sprintf "let [<Literal>] private %s = %i" name value
          |> writer.WriteLine
  
      /// Creates a Map whose keys are the values of the given Map.
      /// The value associated with each key is None.
      let private valueMap (map : Map<'Key, 'T>) : Map<'T, 'U option> =
          (Map.empty, map)
          ||> Map.fold (fun valueMap _ value ->
              Map.add value None valueMap)
  
      /// The name of the end-of-input terminal.
      let [<Literal>] private endOfInputTerminal : TerminalIdentifier = "end_of_input"
      /// The name of the error terminal.
      let [<Literal>] private errorTerminal : TerminalIdentifier = "error"
  
      //
      let emit (processedSpec : ProcessedSpecification<NonterminalIdentifier, TerminalIdentifier>,
  