anchor.diff:  (defmethod shared-initialize :after
       ((obj updating-output-record-mixin) slot-names
        &key (x-position 0.0d0) (y-position 0.0d0))
  +  (declare (ignore x-position y-position))
     (declare (ignore slot-names))
     (setf (explicit-moves obj) nil))
   
  
positive.code: 					  erases)))
  			      old-children
  			      visible-region))
      ;(break)
      ;; Visit this record's updating-output children and merge in the
      ;; difference set. We need to visit all updating-output records, not just
      ;; ones in the visible region, because they might have old records that
      ;; lie in the visible region and that need to be erased.
      (map-over-child-updating-output #'(lambda (r)
  					(multiple-value-bind (e m d)
  					    (compute-difference-set r)
  					  (setf erases (nconc e erases))
  					  (setf moves (nconc m moves))
  					  (setf draws (nconc d draws))))
  				    (sub-record record)
  				    nil)
      ;; Finally, look for updating-output children that were not visited. They
      ;; may have display records equal to ones we already have; otherwise their
      ;; records need to be erased.
      (when old-children
        (map-over-child-updating-output
         #'(lambda (r)
  	   (when (eq (output-record-dirty r) :updating)
  	     (map-over-displayed-output-records
  	      #'(lambda (dr)		;All of them
  		  (multiple-value-bind (draws2 found)
  		      (delete-1 dr draws :test #'output-record-equal)
  		    (if found
  			(setq draws draws2)
  			(push (list dr (copy-bounding-rectange dr)) erases))))
  	      r
  	      t
  	      t
  	      visible-region)))
         old-children
         visible-region))
      (values erases moves draws nil nil)))
  
  (defparameter *enable-updating-output* t
    "Switch to turn on incremental redisplay")
  
negative.code: 					   stream)))))))
  
  (defmethod dump-updating-aux (record old-records stream)
    (declare (ignore old-records))
    (write record :stream stream))
  
  (defmethod redisplay-frame-pane
  