anchor.diff:      (or (find-symbol name :varjo)
           (intern name))))
   
  -(defvar *binary-op-lookup*
  +(defparameter *binary-op-lookup*
     '((addition . +)
       (subtraction . -)
       (division . /)
       (multiplication . *)
       (modulus . mod)
  -    (left-shift . foo)
  -    (right-shift . foo)
  +    (left-shift . <<)
  +    (right-shift . >>)
       (less-than . <)
       (greater-than . >)
       (less-equal-than . <=)
       (greater-equal-than . >=)
       (equal . ==)
       (not-equal . !=)
  -    (bitwise-and . foo)
  -    (exclusive-or . foo)
  -    (inclusive-or . foo)
  -    (logical-and . foo)
  -    (logical-xor . foo)
  -    (logical-or . foo)))
  +    (bitwise-and . &)
  +    (exclusive-or . ^)
  +    (inclusive-or . |\||)
  +    (logical-and . and)
  +    (logical-xor . ^)
  +    (logical-or . or)))
   
   (defun import-binary-operator (form)
     (dbind (op left right) form
  
positive.code: (defun import-place (primary)
    (typecase primary
      (string (import-var-identifier primary))
      (t (error "not implemented"))))
  
  (defun import-swizzle (primary swizzle)
    `(s~ ,(import-swizzlable-form primary)
  
negative.code:     ;; (logical-or)
      ))
  
  (defun import-bool-when (test then)
    `(when ,(import-form test)
       ,(import-form then)))
  
  (defun import-bool-if (test then else)
    `(if ,(import-form test)
         ,(import-form then)
         ,(import-form else)))
  
  (defun import-inversion (form)
    `(not ,(import-form form)))
  
  (defun import-conditional (op left right then else)
    (if else
        `(if (,(cdr (assoc op *ops*)) ,(import-form left) ,(import-form right))
  