anchor.diff:    (every #'(lambda (el) (typep el 'list)) tree))
   
   (defun pick-random-subtree (tree
  -                             &optional (replacement nil) (orig tree) (acc '()))
  +                             &optional (replacement nil) (acc '()))
     (let ((branches (cdr tree)))
       (if (is-tree branches)
         (let* ((pick-number (random (length branches)))
  -             (acc (append acc (list pick-number)))
  +             (acc (append acc (+ 1 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))))
  +          (pick-random-subtree pick replacement acc)
  +          (if replacement acc pick)))
  +      (if replacement (if acc
  +                        acc (list (+ 1 (random (length branches))))) tree))))
   
   (defun recursive-nth (tree nth-list)
     (let ((target (nth (car nth-list) tree)))
  
positive.code:       (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)))
  
  (defun crossover (mother father)
    (let ((father-st (pick-random-subtree father))
          (mother-st (pick-random-subtree mother father)))
      mother-st))
  
  (defun copy-population (fitness-alist &optional (percentage 10) (program-count 7))
  
negative.code:              generation
               (generate-population primitives actions conditionals max-tree-depth member-count)))
           (population-fitness (generation-fitness population args fargs fitness-function repeat-var))
           (passes (remove-if-not #'(lambda (x) (fitness-p (cdr x))) population-fitness)))
      (if passes
        passes
        (evolve primitives actions conditionals args fargs fitness-function fitness-p
  