anchor.diff:  			 (total-severity :accessor total-severity
   					 :initform 0
   					 :type 'integer)
  +			 (caught :accessor caught
  +				 :initform nil)
   			 (player-position :accessor player-position
   					  :initform nil)))
   
  
positive.code: 			      :initarg :depth
  			      :initform (error "The :depth parameter must be provided")
  			      :type 'integer)
  		       (scan-position :accessor scan-position
  				      :initform 0 
  				      :type 'integer)))
  
negative.code: (defgeneric reset-component (component))
  
  (defmethod reset-component ((component firewall))
    (setf (scan-position component) 0))
  
  (defmethod reset-component ((component game-board))
    (setf (player-position component) nil)
    (setf (total-severity component) 0)
    (setf (caught component) nil)
    (dolist (layer (layers component))
      (reset-component layer)))
  
  (defun run-game (board &key delay)
    (dotimes (i (or delay 0))
      (step-component board :skip-player t))
    (do ()
        ((> (or (player-position board) -1) (last-layer board)) board)
      (step-component board)))
  
  (defun run-day13a (filename)
    (total-severity (run-game (parse-input filename))))
  
  ;;; Determine the position of a firewall at the specified time-slice
  (defun position-at-time (firewall time-slice)
    ;;; Determine the position
    (let* ((depth (depth firewall))
  	 (x (* (1- depth) 2))
  	 (pos (mod time-slice x)))
      ;; Pos is actually not the position, we have to figure out if it's on the upswing
      ;; or the downswing
      (if (> pos (1- depth))
  	(- x pos)
  	pos)))
  
  (defun would-be-caught (board start-time)
    (dolist (layer (layers board))
      ;; Get the position at this layer
      (let ((firewall-pos (position-at-time layer (+ start-time (index layer)))))
        (when (= firewall-pos 0)
  	(return-from would-be-caught t)))))
  
  (defun run-day13b (filename &key (patience 10000000))
    (let ((board (parse-input filename)))
      (dotimes (i patience) ; Patience value just to prevent infinite loop
        (when (not (would-be-caught board i))
  	(return-from run-day13b i)))))
  
    
  