anchor.diff:        (error "COMPILEF can only compile lambda expressions."))
       (compile nil lambda-expression)))
   
  -(define-modify-macro* compile-file (&place input-file
  -					   &key output-file
  -					   verbose
  -					   print
  -					   external-format))
  -
  -(define-modify-macro* compile-file-pathname (input-file
  -					     &key output-file
  -					     &allow-other-keys))
  -
  -(define-modify-macro* compiled-function-p (&place object))
  -
  -(define-modify-macro* compiler-macro-function (&place name &optional environment))
  -
  -(define-modify-macro* complement (&place function))
  -
  -(define-modify-macro* complex (&place realpart &optional imagpart))
  -(define-modify-macro* (complex *) (realpart &place imagpart))
  -
  -(define-modify-macro* complexp (&place object))
  -
  -(define-modify-macro* compute-applicable-methods (&place generic-function
  -							 function-arguments))
  -(define-modify-macro* (compute-applicable-methods *) (generic-function
  -						      &place function-arguments))
  -
  -(define-modify-macro* compute-restarts (&place condition))
  -
  -(define-modify-macro* concatenate (result-type &place sequence &rest sequences))
  -(define-modify-macro* (concatenate *) (result-type &rest sequences &place sequence))
  -
  -(define-modify-macro* concatenated-stream-streams (&place concatenated-stream))
  -
  -(define-modify-macro* conjugate (&place number))
  -
  -(define-modify-macro* cons (&place object-1 object-2))
  -(define-modify-macro* (cons *) (object-1 &place object-2)) ; FE to push
  -
  -(define-modify-macro* consp (&place object))
  -
  -(define-modify-macro* constantly (&place place))
  -
  -(define-modify-macro* constantp (&place form &optional environment))
  -
  -
  -
  -
  -;; old begin
  -(flet ((helper (value &rest other-values)
  -	 (labels ((recurse (previous-value next-values)
  -		    (if previous-value
  -			(if (endp next-values)
  -			    previous-value
  -			    (recurse (car next-values) (cdr next-values)))
  -			(return-from andf-helper nil))))
  -	   (recurse value other-values))))
  -  (define-modify-macro andf (&place place &rest other-values) #'helper)
  -  (define-modify-macro andf* (&rest preceding-values &place place) #'helper))
  -
  -
  -
  -(macrolet ((d (&rest function-names)
  -	     `(progn
  -		,@(mapcar
  -		   (lambda (name)
  -		     `(define-modify-macro ,(intern (format nil "~A~A" name 'f))
  -			  () ,name))
  -		   function-names))))
  -  (d caar
  -     cadr
  -     car
  -     cdar
  -     cddr
  -     cdr))
  -
  -(macrolet ((d (&rest function-names)
  -	     `(progn
  -		,@(mapcar
  -		   (lambda (name)
  -		     `(define-modify-macro ,(intern (format nil "~A~A" name 'f))
  -			  (&place number-place &optional (divisor 1)) ,name))
  -		   function-names))))
  -  (d ceiling
  -     fceiling
  -     ffloor
  -     floor
  -     fround
  -     ftruncate))
  -
  -(define-modify-macro char-downcasef (&place character-place) char-downcase)
  -
  -(define-modify-macro char-upcasef (&place character-place) char-upcase)
  -
  -(define-modify-macro characterf (&place character-designator-place) character)
  -
  -(define-modify-macro coercef (result-type) coerce)
  -
  -(define-modify-macro compilef (must-be-nil &place lambda-expression)
  -  (lambda (must-be-nil lambda-expression)
  -    (when must-be-nil
  -      (error "The first argument to COMPILEF must be NIL."))
  -    (unless (typep lambda-expression '(cons (eql lambda)))
  -      (error "COMPILEF can only compile lambda expressions."))
  -    (compile nil lambda-expression)))
  -
  -(define-modify-macro complementf (&place function-place) complement)
  -
  -(define-modify-macro concatenatef (result-type
  -				   &place sequence-place
  -				   &rest other-sequences)
  -  concatenate)
  -(define-modify-macro concatenatef* (result-type
  -				    &rest preceding-sequences
  -				    &place sequence-place)
  -  concatenate)
  -
  -(define-modify-macro constantlyf () constantly)
  -
  -(define-modify-macro copy-alistf (&place alist-place) copy-alist)
  -
  -(define-modify-macro copy-listf (&place list-place) copy-list)
  -
  -(define-modify-macro copy-pprint-dispatchf (&place dispatch-table-place)
  -  copy-pprint-dispatch)
  -
  -(define-modify-macro copy-readtablef (&place from-readtable-place to-readtable)
  -  copy-readtable)
  -
  -(define-modify-macro copy-readtablef* (&place from-readtable to-readtable-place)
  -  copy-readtable)
  -
  -(define-modify-macro copy-seqf (&place sequence-place) copy-seq)
  -
  -(define-modify-macro copy-structuref (&place structure-place) copy-structure)
  -
  -(define-modify-macro copy-symbolf (&place symbol-place &optional copy-properties)
  -  copy-symbol)
  -
  -(define-modify-macro copy-treef (&place tree-place) copy-tree)
  -
  -(define-modify-macro deletef (item &place sequence-place &rest rest
  -			      &key from-end test test-not start end count key)
  -  delete)
  -
  -(define-modify-macro delete-duplicatesf (&place sequence-place &rest rest
  -					 &key from-end test test-not start end key)
  -  delete-duplicates)
  -
  -(define-modify-macro delete-iff (test &place sequence-place &rest rest
  -				 &key from-end start end count key)
  -  delete-if)
  -
  -(define-modify-macro delete-if-notf (test &place sequence-place &rest rest
  -				     &key from-end start end count key)
  -  delete-if-not)
  -
  -(define-modify-macro deposit-fieldf (newbyte bytespec &place integer)
  -  deposit-field)
  -
  -(define-modify-macro digit-charf (&place weight-place &optional radix)
  -  digit-char)
  -
  -(define-modify-macro digit-char-pf (&place char-place &optional radix)
  -  digit-char-p)
  -
  -(define-modify-macro directoryf (&place pathspec-place &rest keys &key)
  -  directory)
  -
  -(define-modify-macro directory-namestringf (&place pathname-designator-place)
  -  directory-namestring)
  -
  -(define-modify-macro dpbf (newbyte bytespec &place integer-place) dpb)
  -
  -(define-modify-macro enough-namestringf (&place pathname-place &optional defaults)
  -  enough-namestring)
  -
  -(define-modify-macro evalf (&place form-place) eval)
  -
  -(define-modify-macro fdefinitionf (&place function-name-place)
  -  fdefinition)
  -
  -(define-modify-macro fifthf (&place list-place) fifth)
  -
  -(define-modify-macro find-classf (&place symbol-place &optional errorp environment)
  -  find-class)
  -
  -(define-modify-macro find-packagef (&place string-designator-or-package)
  -  find-package)
  -
  -(define-modify-macro find-restartf (&place symbol-or-restart &optional condition)
  -  find-restart)
  -
  -(define-modify-macro firstf (&place list-place) first)
  -
  -(define-modify-macro floatf (&place number-place &optional prototype))
  -
  -(define-modify-macro fourthf (&place list-place) first)
  -
  -(define-modify-macro funcallf (function &place arg-place &rest other-args) funcall)
  -(define-modify-macro funcallf* (function &rest preceding-args &place arg-place) funcall)
  -
  -;(define-modify-macro gcdf ())
  +(%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
  +    )
  
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: (in-package #:place-utils)
  
  (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)
  	     `(%d ,name
  		  ((,name *) 2))))
    (d bit-and
       bit-andc1
       bit-andc2
  