anchor.diff:    (loop for s-count upto (* (length fitness-alist) (/ percentage 100)) collect
           (tournament-selection fitness-alist program-count)))
   
  -(defun crossover-population (fitness-alist &optional (percentage 10) (program-count 7))
  +(defun crossover-population (fitness-alist &optional (percentage 90) (program-count 7))
     (loop for s-count upto (* (length fitness-alist) (/ percentage 100)) collect
           (let ((mother (tournament-selection fitness-alist program-count))
                 (father (tournament-selection fitness-alist program-count)))
  
positive.code:   (let ((branches (cdr tree)))
      (if (is-tree branches)
        (let* ((pick-number (random (length branches)))
               (acc (append acc (+ 1 list pick-number)))
               (pick (nth pick-number branches)))
          (if (fair-coin 75)
            (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)))
  
negative.code:       (quote tree))))
  
  (defun replace-subtree (tree nth-list replacement)
    (if (and (is-tree (cdr 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 (reverse nth-list)) tree replacement)))
          tree))
      tree))
  
  (defun crossover (mother father)
    (let* ((father-st (pick-random-subtree father))
           (mother-st-acc (pick-random-subtree mother father-st))
           (mother-st (replace-subtree mother mother-st-acc father-st)))
      mother-st))
  
  