anchor.diff:      ((EQ Symbol '-)  'shen.subtract)
       ((EQ Symbol '/)  'shen.divide)
       ((EQ Symbol '*)  'shen.multiply)
  -    (T Symbol)))
  +    (T               Symbol)))
  
positive.code:             (IF (shen.wrapper (shen.partial-application? (CAR Expr) Args))
                (shen.partially-apply (CAR Expr) Args)
                (CONS (shen.maplispsym (CAR Expr)) Args)))))))
      ((NULL Expr)
       ())
      ((EQ (SYMBOLP Expr) (QUOTE T))
       (LIST (QUOTE QUOTE) Expr))
      (T
       Expr)))
  
  
negative.code: 
  (DEFUN shen.wrap (Expr)
    (COND
  
      ; [cons? X] -> [(protect CONSP) X]
      ((AND
        (CONSP Expr)
        (EQ 'cons? (CAR Expr))
        (CONSP (CDR Expr))
        (NULL (CDDR Expr)))
       (CONS 'CONSP (CDR Expr)))
  
      ; [string? X] -> [(protect STRINGP) X]
      ((AND
        (CONSP Expr)
        (EQ 'string? (CAR Expr))
        (CONSP (CDR Expr))
        (NULL (CDDR Expr)))
       (CONS 'STRINGP (CDR Expr)))
  
      ; [number? X] -> [(protect NUMBERP) X]
      ((AND
        (CONSP Expr)
        (EQ 'number? (CAR Expr))
        (CONSP (CDR Expr))
        (NULL (CDDR Expr)))
       (CONS 'NUMBERP (CDR Expr)))
  
      ; [empty? X] -> [(protect NULL) X]
      ((AND
        (CONSP Expr)
        (EQ 'empty? (CAR Expr))
        (CONSP (CDR Expr))
        (NULL (CDDR Expr)))
       (CONS 'NULL (CDR Expr)))
  
      ; [and P Q] -> [(protect AND) (wrap P) (wrap Q)]
      ((AND
        (CONSP Expr)
        (EQ 'and (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr)))
       (LIST* 'AND (shen.wrap (CADR Expr)) (shen.wrap (CADDR Expr)) NIL))
  
      ; [or P Q] -> [(protect OR) (wrap P) (wrap Q)]
      ((AND
        (CONSP Expr)
        (EQ 'or (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr)))
       (LIST* 'OR (shen.wrap (CADR Expr)) (shen.wrap (CADDR Expr)) NIL))
  
      ; [not P] -> [(protect NOT) (wrap P)]
      ((AND
        (CONSP Expr)
        (EQ 'not (CAR Expr))
        (CONSP (CDR Expr))
        (NULL (CDDR Expr)))
       (LIST* 'NOT (shen.wrap (CADR Expr)) NIL))
  
      ; [equal? X []] -> [(protect NULL) X]
      ((AND
        (CONSP Expr)
        (EQ 'shen.equal? (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CADDR Expr))
        (NULL (CDDDR Expr)))
       (LIST* 'NULL (CADR Expr) NIL))
  
      ; [equal? [] X] -> [(protect NULL) X]
      ((AND
        (CONSP Expr)
        (EQ 'shen.equal? (CAR Expr))
        (CONSP (CDR Expr))
        (NULL (CADR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr)))
       (CONS 'NULL (CDDR Expr)))
  
      ; [equal? X [Quote Y]] -> [(protect EQ) X [Quote Y]] where (and (= ((protect SYMBOLP) Y) (protect T)) (= Quote (protect QUOTE)))
      ; [equal? [Quote Y] X] -> [(protect EQ) [Quote Y] X] where (and (= ((protect SYMBOLP) Y) (protect T)) (= Quote (protect QUOTE)))
      ; [equal? [fail] X] -> [(protect EQ) [fail] X]
      ; [equal? X [fail]] -> [(protect EQ) X [fail]]
      ((OR
        (AND
          (CONSP Expr)
          (EQ 'shen.equal? (CAR Expr))
          (CONSP (CDR Expr))
          (CONSP (CDDR Expr))
          (CONSP (CADDR Expr))
          (CONSP (CDADDR Expr))
          (NULL (CDR (CDADDR Expr)))
          (NULL (CDDDR Expr))
          (EQ (SYMBOLP (CAR (CDADDR Expr))) 'T)
          (EQ (CAADDR Expr) 'QUOTE))
        (AND
          (CONSP Expr)
          (EQ 'shen.equal? (CAR Expr))
          (CONSP (CDR Expr))
          (CONSP (CADR Expr))
          (CONSP (CDADR Expr))
          (NULL (CDDADR Expr))
          (CONSP (CDDR Expr))
          (NULL (CDDDR Expr))
          (EQ (SYMBOLP (CADADR Expr)) 'T)
          (EQ (CAADR Expr) 'QUOTE))
        (AND
          (CONSP Expr)
          (EQ 'shen.equal? (CAR Expr))
          (CONSP (CDR Expr))
          (CONSP (CADR Expr))
          (EQ 'fail (CAADR Expr))
          (NULL (CDADR Expr))
          (CONSP (CDDR Expr))
          (NULL (CDDDR Expr)))
        (AND
          (CONSP Expr)
          (EQ 'shen.equal? (CAR Expr))
          (CONSP (CDR Expr))
          (CONSP (CDDR Expr))
          (CONSP (CADDR Expr))
          (EQ 'fail (CAADDR Expr))
          (NULL (CDADDR Expr))
          (NULL (CDDDR Expr))))
       (CONS 'EQ (CDR Expr)))
  
      ; [equal? S X] -> [(protect EQUAL) S X] where (string? S)
      ; [equal? X S] -> [(protect EQUAL) X S] where (string? S)
      ((OR
        (AND
          (CONSP Expr)
          (EQ 'shen.equal? (CAR Expr))
          (CONSP (CDR Expr))
          (CONSP (CDDR Expr))
          (NULL (CDDDR Expr))
          (STRINGP (CADR Expr)))
        (AND
          (CONSP Expr)
          (EQ 'shen.equal? (CAR Expr))
          (CONSP (CDR Expr))
          (CONSP (CDDR Expr))
          (NULL (CDDDR Expr))
          (STRINGP (CADDR Expr))))
       (CONS 'EQUAL (CDR Expr)))
  
      ; [equal? X N] -> [(protect EQL) X N] where (number? N)
      ((AND
        (CONSP Expr)
        (EQ 'shen.equal? (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr))
        (NUMBERP (CADDR Expr)))
       (LIST 'IF (LIST 'NUMBERP (CADR Expr)) (CONS '= (CDR Expr))))
  
      ; [equal? N X] -> [(protect EQL) X N] where (number? N)
      ((AND
        (CONSP Expr)
        (EQ 'shen.equal? (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr))
        (NUMBERP (CADR Expr)))
       (LIST 'IF (CONS 'NUMBERP (CDDR Expr)) (LIST '= (CADDR Expr) (CADR Expr))))
  
      ; [equal? X Y] -> [(protect shen.ABSEQUAL) X Y]
      ((AND
        (CONSP Expr)
        (EQ 'shen.equal? (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr)))
       (CONS 'shen.ABSEQUAL (CDR Expr)))
  
      ; [greater? X Y] -> [> X Y]
      ((AND
        (CONSP Expr)
        (EQ 'shen.greater? (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr)))
       (CONS '> (CDR Expr)))
  
      ; [greater-than-or-equal-to? X Y] -> [>= X Y]
      ((AND
        (CONSP Expr)
        (EQ 'shen.greater-than-or-equal-to? (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr)))
       (CONS '>= (CDR Expr)))
  
      ; [less? X Y] -> [< X Y]    
      ((AND
        (CONSP Expr)
        (EQ 'shen.less? (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr)))
       (CONS '< (CDR Expr)))
  
      ; [less-than-or-equal-to? X Y] -> [<= X Y]
      ((AND
        (CONSP Expr)
        (EQ 'shen.less-than-or-equal-to? (CAR Expr))
        (CONSP (CDR Expr))
        (CONSP (CDDR Expr))
        (NULL (CDDDR Expr)))
       (CONS '<= (CDR Expr)))
  
      ; X -> [wrapper X]
      (T
       (CONS 'shen.wrapper (CONS Expr NIL)))))
  
  (DEFUN shen.wrapper (X)
    (COND
  