anchor.diff:               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 (cadr x))) population-fitness)))
  +         (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
  
positive.code:   (if (> repeat-var 0)
      (macrolet ((program (code) `(eval (list 'lambda args ,code))))
        (let ((result (apply (program tree) fargs)))
          (cons result (evaluate-tree tree (- repeat-var 1) args result))))
      nil))
  
  (defun evaluate-population (population repeat-var args fargs)
  
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)))
  