anchor.diff:        (quote tree))))
   
   (defun replace-subtree (tree nth-list replacement)
  -  (macrolet
  -    ((macro-nth (atree list-nth)
  -                `(eval (list 'lambda '(tree replacement)
  -                             (list 'setf (recursive-nth ,atree ,list-nth) 'replacement)))))
  -    (let ((setf-return (funcall (macro-nth tree nth-list) tree replacement)))
  -      tree)))
  +  (if nth-list
  +    (macrolet
  +      ((macro-nth (atree list-nth)
  +                  `(eval (list 'lambda '(tree replacement)
  +                               (list 'setf (recursive-nth ,atree ,list-nth) 'replacement)))))
  +      (let ((setf-return (funcall (macro-nth tree nth-list) tree replacement)))
  +        tree))
  +    tree))
   
   (defun crossover (mother father)
  -  (let ((father-st (pick-random-subtree father))
  -        (mother-st (pick-random-subtree mother father)))
  +  (let* ((father-st (pick-random-subtree father))
  +         (mother-st-acc (pick-random-subtree mother father))
  +         (mother-st (replace-subtree mother mother-st-acc father-st)))
       mother-st))
   
   (defun copy-population (fitness-alist &optional (percentage 10) (program-count 7))
  
positive.code:   (every #'(lambda (el) (typep el 'list)) tree))
  
  (defun pick-random-subtree (tree
                               &optional (replacement nil) (orig tree) (acc '()))
    (let ((branches (cdr tree)))
      (if (is-tree branches)
        (let* ((pick-number (random (length branches)))
               (acc (append acc (list pick-number)))
               (pick (nth pick-number branches)))
          (if (fair-coin 75)
            (pick-random-subtree pick replacement orig acc)
            (if replacement
              (replace-subtree orig nth-list replacement)
              pick)))
        (if replacement
          (replace-subtree orig nth-list replacement)
          tree))))
  
  (defun recursive-nth (tree nth-list)
    (let ((target (nth (car nth-list) tree)))
  
negative.code:                    (evaluate-population population repeat-var args fargs))))
  
  (defun get-min-max (alist predicate key)
    (when alist
      (let* ((m0 (first alist))
             (m1 (funcall key m0)))
        (mapc (lambda (e0 &aux (e1 (funcall key e0)))
                (when (funcall predicate e1 m1)
                  (psetf m0 e0 m1 e1)))
              alist)
        m0)))
  
  (defun tournament-selection (fitness-alist program-count)
    (car (get-min-max (loop for r-count upto (- program-count 1) collect
                            (pick-random fitness-alist)) #'> #'cdr)))
  
  (defun fair-coin (chance)
    (let ((toss (random 101)))
  