anchor.diff:             (if (and (< rxs width) (< rys height) (> rxs 0) (> rys 0))
                  (set-pixel img (truncate rys) (truncate rxs) 255 255 255)))
             )))
  -      (with-open-file (output file-name :element-type '(unsigned-byte 8) :direction :output :if-exists :supersede)
  +    (with-open-file (output file-name :element-type '(unsigned-byte 8) :direction :output :if-exists :supersede)
                       (png:encode img output))))
   
   
  
positive.code: 
     (labels
  
  	((draw-tree
  	  (x y length angle transparency depth )
  
  	  (multiple-value-bind
  	   (nx ny) (to-cart length angle)
  
  	   (cl-cairo2:set-source-rgba 0 1.0 0 transparency)
  	   (cl-cairo2:set-line-width (+ 1 (* 1.25 depth)))
  	   (cl-cairo2:move-to x y)
  	   (cl-cairo2:line-to (+ x nx) (+ y ny))
  	   (cl-cairo2:stroke)
  
         (if (> depth 0)
             (dotimes (i limbs)
  
negative.code:   (setf ymin (coerce ymin 'double-float))
    (setf xmax (coerce xmax 'double-float))
    (setf ymax (coerce ymax 'double-float))
    
    (let ((img (png:make-image height width 3 8)))
      (dotimes (i (png:image-height img))
        (declare (i (unsigned-byte 32)))
  
        (let ((yp (map-val i height ymax ymin)))
          (declare (xp double-float))
  
          (dotimes (j (png:image-width img))
            (declare (j (unsigned-byte 32)))
  
            (let ((iters
                   (do* ((xp (map-val j width xmin xmax))
                         
                         (cp (complex xp yp) (+ (* cp cp) (complex xp yp)))
                         (iter 0 (incf iter)))
                        ((or (>= iter iterations) (> (abs cp) 4.0)) iter)
                        (declare (xp double-float))
                        (declare (cp double-complex))
                        (declare (iter (unsigned-byte 32)))
                        )))
              (declare (iters (unsigned-byte 32)))
              (assign-pixel img i j iters iterations)))))
      (with-open-file (output file-name :element-type '(unsigned-byte 8) :direction :output :if-exists :supersede)
                      (png:encode img output))))
  
  (defun make-mandelbrot-window (&key (file-name)
                                      (width 100) (height 100)
                                      (xloc 0.0) (yloc 0.0)
                                      (xwin 3.0) (ywin 2.0)
                                      (iterations 100))
    "Generate a Mandelbrot Set fractal and save to the file name given. The portion of the set drawn is centered at xloc,yloc with a window xwin wide and ywin tall."
    (let ((hx (/ xwin 2.0))
          (hy (/ ywin 2.0)))
      (make-mandelbrot :file-name file-name
                       :width width :height height
                       :xmin (- xloc hx)
                       :xmax (+ xloc hx)
                       :ymin (- yloc hy)
                       :ymax (+ yloc hy)
                       :iterations iterations)))
  
  (defun make-mandelbrot-animation (&key (file-name-format "image~a.png")
                                         (width 100)
                                         (height 100)
                                         (iterations 100)
                                         (xloc 0.0)
                                         (yloc 0.0)
                                         (xwin 3.0)
                                         (ywin 0.5)
                                         (zoom 10.0)
                                         (count 10))
    "Generate a series of Mandelbrot Set images, zooming into the location xloc,yloc. The initial window width and height are given by xwin and ywin.  The number of images is given by count. Zoom specifies how much to zoom in for each frame.  The file-name-format parameter specifies a format string that can be used in the call (format t file-name-format i) to generate a file name for the ith file in the sequence - typically something like image~a.png."
    (dotimes (i count)
      (let ((cxwin (/ xwin (expt zoom i)))
            (cywin (/ ywin (expt zoom i))))
        (format t "window: ~a ~a~%" cxwin cywin)
        (make-mandelbrot-window :file-name (format nil file-name-format i)
                                :width width :height height
                                :xloc xloc
                                :yloc yloc
                                :xwin cxwin
                                :ywin cywin
                                :iterations iterations))))
  
  (defun home-dir (path)
    "Utility function to make relative path names relative to the user's home directory to work around Cairo weirdness."
  