anchor.diff:        (loop for i from 1 to (1- (length numbers))
               for partition = (split numbers i) append 
             (loop for arg1 in (make-exprs (car partition)) append 
  -              (loop for arg2 in (make-exprs (cdr partition)) collect 
  +              (loop for arg2 in (make-exprs (cadr partition)) append 
                   (apply-binary-ops arg1 arg2))))))
   
   (defun apply-unary-ops (arg1)
  
positive.code:   (cond ((numberp expr) (list expr))
          ((unary-p expr) expr)
          ((binary-p expr)
           (append (infix-arg (first expr) (second expr))
                   (cons (first expr)
                     (infix-arg (first expr) (third expr))))))
  
  (defun infix-arg (op expr &aux (res (prefix-to-infix expr)))
    "Optionally add parentheses to the infix notation of EXPR, as an argument to OP."
    (if (or (not (binary-p expr))
            ;; compare precedence
            (< (position op *binary-ops*)
               (position (first expr) *binary-ops*)))
        res
        (cons '[ (append res (list '])))))
  
  (defun infix-to-prefix (expr)
    "Convert an infix arithmetic expression, expressed as a list of numbers, operators and brackets, into a Lisp expression."
  
negative.code:                         ;; remove all but the expressions whose value is the same as rhs-expr
                          (remove rhs-expr (make-exprs lhs)
                            :test-not #'eql
                            :key #'eval)))
                (make-exprs rhs))))
  
  (defun make-exprs (numbers)
  