anchor.diff:  (in-package #:place-utils)
   
  -(define-modify-macro* * (&place number &rest numbers))
  -(define-modify-macro* (* *) (&rest numbers &place number))
  -
  -(define-modify-macro* + (&place number &rest numbers))
  -(define-modify-macro* (+ *) (&rest numbers &place number))
  -
  -(define-modify-macro* - (&place number &rest numbers))
  -(define-modify-macro* (- *) (&rest numbers &place number))
  -
  -(define-modify-macro* / (&place numerator &rest denominators))
  -(define-modify-macro* (/ *) (&rest numbers &place number))
  -
  -(define-modify-macro* /= (&place number &rest numbers))
  -(define-modify-macro* (/= *) (&rest numbers &place number))
  -
  -(define-modify-macro* 1+ (&place number))
  -(define-modify-macro* 1- (&place number))
  -
  -(define-modify-macro* < (&place number &rest numbers))
  -(define-modify-macro* (< *) (&rest numbers &place number))
  -
  -(define-modify-macro* <= (&place number &rest numbers))
  -(define-modify-macro* (<= *) (&rest numbers &place number))
  -
  -(define-modify-macro* = (&place number &rest numbers))
  -(define-modify-macro* (= *) (&rest numbers &place number))
  -
  -(define-modify-macro* > (&place number &rest numbers))
  -(define-modify-macro* (> *) (&rest numbers &place number))
  -
  -(define-modify-macro* >= (&place number &rest numbers))
  -(define-modify-macro* (>= *) (&rest numbers &place number))
  -
  -(define-modify-macro* abs (&place number))
  -
  -(define-modify-macro* acons (key datum &place alist)) ; caution
  -
  -(define-modify-macro* acos (&place number))
  -(define-modify-macro* acosh (&place number))
  -
  -;; add-method
  -
  -(define-modify-macro* adjoin (item &place list &key key test)) ; FE to pushnew
  -
  -(define-modify-macro* adjust-array (&place array new-dimensions
  -					   &key element-type
  -					   initial-element
  -					   initial-contents
  -					   fill-pointer
  -					   displaced-to
  -					   displaced-index-offset))
  -
  -(define-modify-macro* adjustable-array-p (&place array))
  -
  -(define-modify-macro* allocate-instance (&place class &rest initargs))
  -
  -(define-modify-macro* alpha-char-p (&place character))
  -
  -(define-modify-macro* alphanumericp (&place character))
  -
  -(define-modify-macro* and (&place form &rest forms))
  -(define-modify-macro* (and *) (&rest forms &place form))
  -
  -(define-modify-macro* append (&place list &rest lists))
  -(define-modify-macro* (append *) (&rest lists &place list))
  -
  -(define-modify-macro* apply (function &place arg &rest args)) ; caution
  -(define-modify-macro* (apply *) (function &rest args &place arg))
  -
  -(define-modify-macro* apropos-list (&place string &optional package))
  -
  -(define-modify-macro* aref (&place array &rest subscripts))
  -(define-modify-macro* (aref *) (array &place first-subscript &rest subscripts))
  -
  -(define-modify-macro* arithmetic-error-operands (&place condition))
  -(define-modify-macro* arithmetic-error-operation (&place condition))
  -
  -(define-modify-macro* array-dimension (&place array axis-number))
  -(define-modify-macro* (array-dimension *) (array &place axis-number))
  -
  -(define-modify-macro* array-dimensions (&place array))
  -
  -(define-modify-macro* array-displacement (&place array))
  -(define-modify-macro* (array-displacement 2) (&place array))
  -
  -(define-modify-macro* array-element-type (&place array))
  -
  -(define-modify-macro* array-has-fill-pointer-p (&place array))
  -
  -(define-modify-macro* array-in-bounds-p (&place array &rest subscripts))
  -
  -(define-modify-macro* array-rank (&place array))
  -
  -(define-modify-macro* array-row-major-index (&place array &rest subscripts))
  -
  -(define-modify-macro* array-total-size (&place array))
  -
  -(define-modify-macro* arrayp (&place object))
  -
  -(define-modify-macro* ash (&place integer count))
  -(define-modify-macro* (ash *) (integer &place count))
  -
  -(define-modify-macro* asin (&place number))
  -(define-modify-macro* asinh (&place number))
  -
  -(define-modify-macro* assoc (item &place alist &key key test))
  -(define-modify-macro* assoc-if (predicate &place alist &key key))
  -(define-modify-macro* assoc-if-not (predicate &place alist &key key))
  -
  -(define-modify-macro* atan (&place number1 &optional number2))
  -(define-modify-macro* (atan *) (number1 &place number2))
  -(define-modify-macro* atanh (&place number))
  -
  -(define-modify-macro* atom (&place object))
  -
  -(define-modify-macro* bit (&place bit-array &rest subscripts))
  -(define-modify-macro* (bit *) (bit-array &place first-subscript &rest subscripts))
  +(defmacro %d (&rest defs)
  +  (declare (ignore defs)))
  +
  +(%d * (* *)
  +    + (+ *)
  +    - (- *)
  +    / (/ *)
  +    /= (/= *)
  +    1+ 1-
  +    < (< *)
  +    <= (<= *)
  +    = (= *)
  +    > (> *)
  +    >= (>= *)
  +    abs
  +    (acons 3)
  +    acos acosh
  +    (adjoin 2)
  +    adjust-array
  +    adjustable-array-p
  +    allocate-instance
  +    alpha-char-p
  +    alphanumericp
  +    (macro and) (macro (and *))
  +    append (append *)
  +    (apply 2) (apply *)
  +    apropos-list
  +    aref ((aref *) 2) ; caution
  +    arithmetic-error-operands
  +    arithmetic-error-operation
  +    array-dimension (array-dimension *)
  +    array-dimensions
  +    array-displacement
  +    array-element-type
  +    array-has-fill-pointer-p
  +    array-in-bounds-p
  +    array-rank
  +    array-row-major-index
  +    array-total-size
  +    arrayp
  +    ash (ash *)
  +    asin asinh
  +    (assoc 2) (assoc-if 2) (assoc-if-not 2)
  +    ((assoc *) 1) ((assoc-if *) 1) ((assoc-if-not *) 1)
  +    atan ((atan *) 2) atanh
  +    atom
  +    bit ((bit *) 2) ; caution
  +    )
   
   (macrolet ((d (&rest function-names)
  -	     `(progn
  -		,@(mapcan
  -		   (lambda (name)
  -		     (list `(define-modify-macro* ,name
  -				(&place bit-array1 bit-array2
  -					&optional optarg))
  -			   `(define-modify-macro* (,name *)
  -				(bit-array1 &place bit-array2
  -					    &optional result-bit-array))))
  -		   function-names))))
  +	     `(%d ,name
  +		  ((,name *) 2))))
     (d bit-and
        bit-andc1
        bit-andc2
  
positive.code:      bit-orc2
       bit-xor))
  
  (define-modify-macro* bit-vector-p (&place object))
  
  (define-modify-macro* boole (op &place integer-1 integer-2))
  (define-modify-macro* (boole *) (op integer-1 &place integer-2))
  
  (define-modify-macro* boolean (&place generalized-boolean) ; caution
    (lambda (generalized-boolean)
      (if generalized-boolean t nil)))
  
  (define-modify-macro* both-case-p (&place character))
  
  (define-modify-macro* boundp (&place symbol))
  
  (define-modify-macro* broadcast-stream-streams (&place broadcast-stream))
  
  (define-modify-macro* butlast (&place list &optional n))
  
  (define-modify-macro* byte (&place size position))
  (define-modify-macro* (byte *) (size &place position))
  
  (define-modify-macro* byte-position (&place bytespec))
  (define-modify-macro* byte-size (&place bytespec))
  
  (macrolet ((d (&rest function-names)
  	     `(progn
  		,@(mapcar
  		   (lambda (name)
  		     `(define-modify-macro* ,name (&place list) ,name))
  		   function-names))))
    (d caar
       cadr
       car
       cdar
       cddr
       cdr))
  
  (define-modify-macro* case (&place keyform &body cases))
  (define-modify-macro* ccase (&place keyplace &body cases))
  (define-modify-macro* ecase (&place keyform &body cases))
  
  (macrolet ((d (&rest function-names)
  	     `(progn
  		,@(mapcan
  		   (lambda (name)
  		     (list `(define-modify-macro ,name
  				(&place number &optional divisor))
  			   `(define-modify-macro (,name *)
  				(number &place divisor))
  			   `(define-modify-macro (,name 2)
  				(&place number &optional divisor))
  			   `(define-modify-macro (,name * 2)
  				(number &place divisor))))
  		   function-names))))
    (d ceiling
       fceiling
       ffloor
       floor
       fround
       ftruncate))
  
  (define-modify-macro* cell-error-name (&place condition))
  
  (define-modify-macro* char (&place string index))
  (define-modify-macro* (char *) (string &place index))
  
  (define-modify-macro* char-code (&place character))
  (define-modify-macro* code-char (&place code))
  (define-modify-macro* char-int (&place character))
  (define-modify-macro* char-name (&place character))
  (define-modify-macro* char-downcase (&place character))
  (define-modify-macro* char-upcase (&place character))
  
  (macrolet ((d (&rest function-names)
  	     `(progn
  		,@(mapcan
  		   (lambda (name)
  		     (list `(define-modify-macro* ,name
  				(&place character &rest characters))
  			   `(define-modify-macro* (,name *)
  				(&rest characters &place character))))
  		   function-names))))
    (d char-equal
       char-greaterp
       char-lessp
       char-not-equal
       char-not-greaterp
       char-not-lessp
       char/=
       char<
       char<=
       char=
       char>
       char>=))
  
  (define-modify-macro* character (&place character-designator))
  (define-modify-macro* characterp (&place object))
  
  (define-modify-macro* cis (&place radians))
  
  (define-modify-macro* class-name (&place class))
  (define-modify-macro* class-of (&place class))
  
  (define-modify-macro* close (&place stream &key abort))
  
  (define-modify-macro* coerce (&place object result-type))
  
  (define-modify-macro* compile (must-be-nil &place lambda-expression) ; caution
    (lambda (must-be-nil lambda-expression)
  
negative.code:       (error "COMPILEF can only compile lambda expressions."))
      (compile nil lambda-expression)))
  
  (%d compile-file
      compile-file-pathname
      compiled-function-p
      compiler-macro-function
      complement
      complex ((complex *) 2)
      complexp
      compute-applicable-methods (compute-applicable-methods *)
      compute-restarts
      (concatenate 2) (concatenate *)
      concatenated-stream-streams
      conjugate
      cons (cons *)
      consp
      constantly
      constantp
  
      copy-alist
      copy-list
      copy-pprint-dispatch
      copy-readtable
      copy-seq
      copy-structure
      copy-symbol
      copy-tree
  
      cos cosh
  
      (count 2) (count-if 2) (count-if-not 2)
  
      decode-float
      decode-universal-time
  
      (delete 2) (delete-duplicates 2) (delete-if 2) (delete-if-not 2)
  
      delete-package
      denominator
      (deposit-field 3)
      (macro destructuring-bind 2)
      digit-char
      digit-char-p
      directory
      directory-namestring
      documentation
      (dpb 3)
      echo-stream-input-stream
      echo-stream-output-stream
      elt (elt *)
      endp
      enough-namestring ((enough-namestring *) 2)
      ensure-directories-exist ; supplied for 2nd return value
      ensure-generic-function
      eq (eq *)
      eql (eql *)
      equal (equal *)
      equalp (equalp *)
      evenp
      (every 2) (every *)
      exp
      expt (expt *)
      fboundp
      fdefinition
      file-author
      file-error-pathname
      file-length
      file-namestring
      file-position
      (file-string-length 2)
      file-write-date
      fill-pointer
      (find 2) (find-if 2) (find-if-not 2) ; caution
      ((find *) 1) ((find-if *) 1) ((find-if-not *) 1)
      find-all-symbols
      find-class
      find-method
      find-package
      find-restart
      find-symbol
      float
      float-digits
      float-precision
      float-radix
      float-sign ((float-sign *) 2)
      floatp
      (funcall 2) (funcall *)
      function-keywords
      function-lambda-expression
      functionp
      gcd (gcd *)
      gensym
      get ((get *) 2)
      get-macro-character ((get-macro-character *) 2)
      get-output-stream-string
      get-properties (get-properties *)
      get-setf-expansion
      getf ((getf *) 2)
      (gethash 2) ((gethash *) 1)
      graphic-char-p
      (macro handler-case)
      hash-table-count
      hash-table-p
      hash-table-rehash-size
      hash-table-rehash-threshold
      hash-table-size
      hash-table-test
      host-namestring
      identity
      imagpart
      initialize-instance
      input-stream-p
      integer-decode-float
      integer-length
      integerp
      interactive-stream-p
      intern ((intern *) 2)
      intersection ((intersection *) 2)
      invoke-restart
      invoke-restart-interactively
      isqrt
      keywordp
      last ((last *) 2)
      lcm (lcm *)
      (ldb 2)
      (ldb-test 2)
      ldiff ((ldiff *) 2)
      length
      list (list *)
      list-length
      listen
      listp
      load
      load-logical-pathname-translations
      log ((log *) 2)
      logand (logand *)
      logandc1 (logandc1 *)
      logandc2 (logandc2 *)
      (logbitp 2) ((logbitp *) 1) ; caution
      logcount
      logeqv (logeqv *)
      logical-pathname
      logical-pathname-translations
      logior (logior *)
      lognand (lognand *)
      lognor (lognor *)
      lognot
      logorc1
      logorc2
      logtest (logtest *)
      logxor (logxor *)
      lower-case-p
      macro-function
      macroexpand
      macroexpand-1
      make-array
      make-broadcast-stream (make-broadcast-stream *)
      make-concatenated-stream (make-concatenated-stream *)
      make-condition
      make-echo-stream (make-echo-stream *)
      make-instance
      make-list
      make-load-form
      make-load-form-saving-slots
      make-package
      make-random-state
      (make-sequence 2) ((make-sequence *) 1) ; caution
      make-string
      make-string-input-stream
      make-symbol
      make-synonym-stream
      make-two-way-stream (make-two-way-stream *)
      (map 3) (map *)
      (map-into 3) (map-into *)
      (mapc 2) (mapc *) ; caution, todo
      (mapcar 2) (mapcar *) (mapcan 2) (mapcan *)
      mapl ; caution, todo
      (maplist 2) (maplist *) (mapcon 2) (mapcon *)
      maphash ; caution, todo
      (maskfield 2)
      max (max *)
      (member 2) (member-if 2) (member-if-not 2) ; caution
      ((member *) 1) ((member-if *) 1) ((member-if-not *) 1)
      (merge 2) ((merge *) 3)
      merge-pathnames
      method-qualifiers
      min (min *)
      minusp
      mismatch ((mismatch *) 2)
      mod (mod *)
      multiple-value-call ; caution, todo
      )
  