anchor.diff:  
   (defun play-mcts (b-num w-num)
     (compete b-num 2 w-num 2 nil nil nil nil nil))
  +
  +;; Basically a wrapper for compete
  +(defun gauntlet (net1 net2 file-lock)
  +  (compete 250 1 250 1 1 1 net1 net2 nil nil t file-lock nil))
   
   (defun run-sims (num)
     (dolist (net1 *lon*)
  
positive.code:               (make-pairs (svref fronts i))))
  
        ;; Add all the pairs into one list
        (dotimes (i num-fronts)
          (dolist (pair (svref fronts i))
            (push pair pairs)))
  
        ;; Evaluate each network's fitness
        ;; Do the fronts one at a time to make better use of memory
        ;(dotimes (i num-fronts)
        ;; Reset the barrier
        (setq barrier (mp:make-barrier (+ 1 (length pairs))))
        (format t "Pairs: ~A ~%" pairs)
        (dolist (pair pairs);(svref fronts i))
          (when (and (first pair)
                     (second pair))
            (format t "Face Off: ~A ~%" pair)
            (if threads? 
              (mp:process-run-function (write-to-string pair) 
                                       #'face-off
                                       pair
                                       gen
                                       barrier
                                       file-lock)
              (face-off pair gen barrier file-lock)
              )
            )
          ;    )
          (format t "Waiting for threads to finish~%")
          ;; Wait for all the trials to finish
          )
  
        (mp:barrier-wait barrier)
  
        (format t "Creating next generation~%")
        ;; Get the next generation
        (setq generation (get-next-gen generation))
        ;; Reset pairs
        (setq pairs (list))
        (setq file-lock nil) 
        )
      (format t "Done!~%")
      ))
  
  
  (defmacro init-lock (gen)
  
negative.code:           ;; Load the network
            (setq w-v-pool (init-nn-pool white-v-network white-threads?))
            ;; Otherwise were provided a network so use it
            (setq w-v-pool (init-pool white-v-network white-threads?))))
  
        (loop while (not (game-over? g))
              do (cond
                   ((eq (gg-whose-turn? g) *black*)
                    (when verbose? (format t "BLACK'S TURN!~%"))
                    (if verbose? (time (do-move! g (uct-search g black-num-sims black-c nil black-threads? b-p-pool b-v-pool)))
                      (do-move! g (uct-search g black-num-sims black-c nil black-threads? b-p-pool b-v-pool)))
                    (when verbose? (print-go g t nil nil nil nil)))
                   (t
                     (when verbose? (format t "WHITE'S TURN!~%"))
                     (if verbose? (time (do-move! g (uct-search g white-num-sims white-c nil white-threads? w-p-pool b-v-pool)))
                       (do-move! g (uct-search g white-num-sims white-c nil white-threads? w-p-pool w-v-pool)))
                     (when verbose? (print-go g t nil nil nil nil)))))
  
        ;; Show most game information at the end
  