anchor.diff:      (let ((parent (output-record-parent record)))
         (when parent
           (recompute-extent-for-changed-child parent record
  -                                            min-x min-y max-x max-y)))))
  +                                            min-x min-y max-x max-y))))
  +  record)
   
   (defmethod* (setf output-record-position) :before
       (nx ny (record compound-output-record))
  
positive.code: (defmethod invoke-with-new-output-record ((stream output-recording-stream)
                                            continuation record-type
                                            &rest initargs
                                            &key parent
  					  &allow-other-keys)
    (stream-close-text-output-record stream)
    (unless parent (setq parent (stream-current-output-record stream)))
    (let ((new-record (apply #'make-instance record-type :parent parent initargs)))
      (letf (((stream-current-output-record stream) new-record))
        ;; Should we switch on recording? -- APD
        (funcall continuation stream new-record)
  
negative.code: 	    (setq children (replace children children
  				    :start1 pos
  				    :start2 (1+ pos)))
  	    (decf (fill-pointer children))
              (setf (output-record-parent child) nil))))))
  
  (defmethod clear-output-record ((record standard-sequence-output-record))
    (let ((children (output-record-children record)))
      (map 'nil (lambda (child) (setf (output-record-parent child) nil))
           children)
      (fill children nil)
      (setf (fill-pointer children) 0)))
  
  