anchor.diff:      /// Emit a formatted string as a single-line F# comment into an IndentedTextWriter.
       let inline private comment (writer : IndentedTextWriter) fmt : ^T =
           writer.Write "// "
  -        Printf.fprintfn writer fmt
  +        fprintfn writer fmt
   
       /// Emits a formatted string as a quick-summary (F# triple-slash comment) into an IndentedTextWriter.
       let inline private quickSummary (writer : IndentedTextWriter) fmt : ^T =
  
positive.code:     //
      let private tablesRecordAndParserFunctions terminalCount (writer : IndentedTextWriter) =
          // Emit the 'tables' record.
          Printf.fprintfn writer "let tables () : %s.Tables<_> = {" defaultParsingNamespace
          IndentedTextWriter.indented writer <| fun writer ->
              writer.WriteLine "reductions = _fsyacc_reductions ();"
              writer.WriteLine "endOfInputTag = _fsyacc_endOfInputTag;"
  
negative.code:             defaultArg options.ModuleName "Parser"
          
          if options.InternalModule then
              fprintfn writer "module internal %s" parserModuleName
          else
              fprintfn writer "module %s" parserModuleName
          writer.WriteLine ()
  
          // Emit a "nowarn" directive to disable a certain type-related warning message.
          fprintf writer "#nowarn \"%i\" " 64
          comment writer "turn off warnings that type variables used in production annotations are instantiated to concrete type"
          writer.WriteLine ()
  
          (* Emit the "open" statements. *)
          [|  defaultLexingNamespace;
              defaultParsingNamespace + ".ParseHelpers"; |]
          |> Array.iter (fprintfn writer "open %s")
          writer.WriteLine ()
  
          (* Emit the header code. *)
          processedSpec.Header
          |> Option.iter (fun header ->
              // Write the header code into the TextWriter.
              // We split the code into individual lines, then write them one at a time to the
              // IndentedTextWriter; this ensures that the newlines are correct for this system
              // and also that the indentation level is correct.
              header.Split ([| "\r\n"; "\r"; "\n" |], StringSplitOptions.None)
              |> Array.iter (fun codeLine ->
                  // TODO : Trim the lines? We'd have to process the entire array first
                  // to determine the "base" indentation level, then trim only that much
                  // from the front of each string.
                  writer.WriteLine codeLine)
  
              writer.WriteLine ())
  
          // Emit the parser types (e.g., the token type).
          let productionIndices =
              parserTypes processedSpec writer
  
          // Emit the parser tables.
          parserTables (processedSpec, parserTable, productionIndices) writer
          reductions processedSpec writer
  
          // Emit the parser "tables" record and parser functions.
          let terminalCount =
  