anchor.diff: -(def and (lambda (and_x and_y)
  +(label and (lambda (and_x and_y)
              (cond (and_x
                     (cond (and_y t)
                           (t nil)))
                    (t nil))))
   
  -(def not (lambda (not_x)
  +(label not (lambda (not_x)
              (cond (not_x nil)
                    (t t))))
   
  -(def nand (lambda (nand_x nand_y)
  +(label nand (lambda (nand_x nand_y)
               (not (and nand_x nand_y))))
   
  -(def or (lambda (or_x or_y)
  +(label or (lambda (or_x or_y)
             (nand
              (nand or_x or_x)
              (nand or_y or_y))))
   
  -(def nor (lambda (nor_x nor_y)
  +(label nor (lambda (nor_x nor_y)
              (not (or nor_x nor_y))))
   
  -(def xor (lambda (xor_x xor_y)
  +(label xor (lambda (xor_x xor_y)
              (or
               (and xor_x (not xor_y))
               (and (not xor_x) xor_y))))
   
  -(def and_ (lambda (x y) (cond (x (cond (y t) (t nil))) (t nil))))
  -(def not_ (lambda (x) (cond (x nil) (t t))))
  -(def nand_ (lambda (x y) (not_ (and_ x y))))
  -(def or_ (lambda (x y) (nand_ (nand_ x x) (nand_ y y))))
  -(def xor_ (lambda (x y) (or_ (and_ x (not_ y)) (and_ (not_ x) y))))
  +(label and_ (lambda (x y) (cond (x (cond (y t) (t nil))) (t nil))))
  +(label not_ (lambda (x) (cond (x nil) (t t))))
  +(label nand_ (lambda (x y) (not_ (and_ x y))))
  +(label or_ (lambda (x y) (nand_ (nand_ x x) (nand_ y y))))
  +(label xor_ (lambda (x y) (or_ (and_ x (not_ y)) (and_ (not_ x) y))))
   
  -(def list (lambda (x y)
  +(label list (lambda (x y)
               (cons x (cons y (quote ())))))
   
  -(def pair (lambda (x y)
  +(label pair (lambda (x y)
               (cond ((and (null x) (null y)) nil)
                     ((and (not (atom x)) (not (atom y)))
                      (cons (list (car x) (car y))
                            (pair (cdr x) (cdr y)))))))
   
  -(def assoc (lambda (x y)
  +(label assoc (lambda (x y)
                (cond ((eq (car (car y)) x) (car (cdr (car y))))
                      (t (assoc x (cdr y))))))
   
  -(def caar (lambda (x) (car (car x))))
  -(def cadr (lambda (x) (car (cdr x))))
  -(def caddr (lambda (x) (car (cdr (cdr x)))))
  -(def cadar (lambda (x) (car (cdr (car x)))))
  -(def caddar (lambda (x) (car (cdr (cdr (car x))))))
  +(label caar (lambda (x) (car (car x))))
  +(label cadr (lambda (x) (car (cdr x))))
  +(label caddr (lambda (x) (car (cdr (cdr x)))))
  +(label cadar (lambda (x) (car (cdr (car x)))))
  +(label caddar (lambda (x) (car (cdr (cdr (car x))))))
   
  -(def null (lambda (null_x)
  +(label null (lambda (null_x)
               (eq null_x nil)))
   
  -(def mapcar (lambda (mapcar_f mapcar_lst)
  +(label mapcar (lambda (mapcar_f mapcar_lst)
                 (cond
                  ((null mapcar_lst) mapcar_lst)
                  (t (cons
                      (mapcar_f (car mapcar_lst))
                      (mapcar mapcar_f (cdr mapcar_lst)))))))
   
  -(def reduce (lambda (reduce_f reduce_lst)
  +(label reduce (lambda (reduce_f reduce_lst)
                 (cond
                  ((null reduce_lst) (reduce_f))
                  (t (reduce_f (car reduce_lst)
                               (reduce reduce_f (cdr reduce_lst)))))))
   
  -(def append (lambda (append_x append_y)
  +(label append (lambda (append_x append_y)
                 (cond ((null append_x) append_y)
                       (t (cons (car append_x) 
                                (append (cdr append_x) append_y))))))
   
  -(def filter (lambda (filter_f filter_lst)
  +(label filter (lambda (filter_f filter_lst)
                 (cond
                  ((null filter_lst) filter_lst)
                  (t (cond
  
positive.code:                                                  (filter filter_f (cdr filter_lst))))
                     (t (filter filter_f (cdr filter_lst))))))))
  
  (def eval (lambda (expr binds)
              (cond
               ((atom expr) (assoc expr binds))
               ((atom (car expr))
  
negative.code:                             binds)))
               (t (assoc expr binds)))))
  
  (label eval-cond (lambda (eval-cond_c eval-cond_a)
                   (cond ((eval (caar eval-cond_c) eval-cond_a)
                          (eval (cadar eval-cond_c) eval-cond_a))
                         (t (eval-cond (cdr eval-cond_c) eval-cond_a)))))
  
  (label eval-args (lambda (eval-args_m eval-args_a)
                   (cond ((null eval-args_m) nil)
                         (t (cons (eval  (car eval-args_m) eval-args_a)
                                  (eval-args (cdr eval-args_m) eval-args_a))))))
  
  (label apply (lambda (apply_name apply_args)
               ((list apply_name (list (quote quote) apply_args)))))
  
  