anchor.diff:                               multiple-columns
                                (multiple-columns-x-spacing nil multiple-columns-x-spacing-supplied-p)
                                equalize-column-widths (move-cursor t)
  -                             (record-type ''empty-standard-table-output-record)
  +                             (record-type 'empty-standard-table-output-record)
                                &allow-other-keys)
                               &body body)
     (when (eq stream t)
  
positive.code: 
  (defmethod adjust-table-cells ((table-record standard-table-output-record)
                                 stream)
    (let* ((cell-spacing (table-cell-spacing table-record))
           (block-spacing (table-block-spacing table-record))
           (infos (collect-block-infos table-record))
           (max-block-length (loop :for info :in infos
                                   :maximize (block-info-number-of-cells info)))
           (sizes (make-array (list max-block-length)
                              :element-type 'coordinate
                              :initial-element (coerce 0 'coordinate))))
      (loop :for info :in infos
            :for block-sizes = (block-info-cell-sizes info)
            :do (loop :for i = 0 :then (1+ i)
                      :for s :in block-sizes
                      :do (setf (aref sizes i)
                                (max (aref sizes i) s))))
      (map-over-table-elements
       (let ((common-coordinate (coerce 0 'coordinate)))
         #'(lambda (block)
             (let ((common-size (block-info-common-size (pop infos))))
               (adjust-block block (coerce sizes 'list)
                             cell-spacing common-coordinate common-size)
               (incf common-coordinate (+ common-size block-spacing)))))
       table-record
  
negative.code:     info))
  
  (defun adjust-block (block sizes spacing common-coordinate common-size)
    "Adjusts cells of the BLOCK. SIZES is a vector of new sizes of the
  of the cells in the BLOCK. SPACING is a space between cells. The BLOCK
  will start at COMMON-COORDININATE and will have COMMON-SIZE on common
  dimension."
    (declare (type block-output-record block)
             (type (vector coordinate) sizes)
             (type coordinate common-coordinate common-size))
    (let ((cell-coordinate (coordinate 0))
          (cell-number 0))
      (map-over-block-cells
       #'(lambda (cell)
           (let ((size (aref sizes cell-number)))
             (block-adjust-cell* cell block
                                 cell-coordinate common-coordinate
                                 size common-size)
             (incf cell-coordinate (+ size spacing))
             (incf cell-number)))
       block)))
  
  
  ;;; Row formatting
  (defclass row-output-record (block-output-record)
    ()
    (:documentation "The protocol class representing row output records."))
  
  (defun row-output-record-p (object)
    (typep object 'row-output-record))
  
  (defgeneric map-over-row-cells (function row-record)
    (:documentation "Applies FUNCTION to all the cells in the row
  ROW-RECORD, skipping intervening non-table output record structures.
  FUNCTION is a function of one argument, an output record corresponding
  to a table cell within the row."))
  
  ;;; Methods
  (defmethod map-over-block-cells (function (block row-output-record))
    (map-over-row-cells function block))
  
  (defmethod cell-common-size (cell (block row-output-record))
    (declare (ignore block)
             (type cell-output-record cell))
    (max (bounding-rectangle-height cell)
         (cell-min-height cell)))
  
  (defmethod cell-size (cell (block row-output-record))
    (declare (ignore block)
             (type cell-output-record cell))
    (max (bounding-rectangle-width cell)
         (cell-min-width cell)))
  
  (defmethod block-adjust-cell* (cell (block row-output-record)
                                 cell-coordinate common-coordinate
                                 size common-size)
    (declare (ignore block)
             (type cell-output-record cell)
             (type coordinate cell-coordinate common-coordinate size common-size))
    (adjust-cell* cell
                  cell-coordinate common-coordinate
                  size common-size))
  