anchor.diff:                                                (if (keywordp val-class)
                                                     (print-prim v val-class nil stream nil)
                                                     (print-text-format v :stream stream
  -                                                                       :suppress-pretty-print t))
  +                                                                       :pretty-print nil))
                                                 (format stream "~%")))
                                          (maphash #'print-entry val)
                                          (format stream "~&~VT}" (+ indent 2)))))
  
positive.code:                             (cond ((keywordp type)
                                     (let ((v (read-slot object slot reader)))
                                       (print-prim v type field stream
                                                   (and (not suppress-pretty-print) indent))))
                                    ((typep (setq msg (and type (or (find-message type)
                                                                    (find-enum type)
                                                                    (find-type-alias type)
  
negative.code: 
  (defun print-text-format (object &key (stream *standard-output*)
                                   (print-name t)
                                   (pretty-print t))
    "Prints a protocol buffer message to a stream.
  Parameters:
    OBJECT: The protocol buffer message to print.
    STREAM: The stream to print to.
    PRINT-NAME: Bool for printing the name of the top level proto message.
    PRETTY-PRINT: When true, generate line breaks and other human readable output
      in the text format. When false, replace line breaks with spaces."
    (let* ((type    (type-of object))
           (message (find-message-for-class type)))
      (assert message ()
  