anchor.diff:  				  (keyed-jewel-set-key cand)
   				  n)))))
       (when jewel-cands
  -	       ;; (<= minimum (max-at-skill (preliminary-forest prelim)
  -	       ;; 				 (split-env-target-id env))))
         (let ((armor-cands (split-forest-at-skill
                             (preliminary-forest prelim)
                             (split-env-target-id env)
  
positive.code: 			  (split-env-inv-req-key env)))
  	 (prelim-holes (decode-hole-sig (hole-part prelim-key))))
      (declare (type (unsigned-byte 64) prelim-key))
      ;; (when (> (length (preliminary-jewel-sets prelim)) 20)
      ;;   (setf trace-signal t)
      ;;   (format t "----------------------------------------~%")
      ;;   (loop for base-list in (preliminary-jewel-sets prelim)
      ;; 	 do (format t "~a: ~a~%" base-list (stuff-jewels-fast prelim-holes
      ;; 							      base-list))))
      (loop 
         for base-list in (preliminary-jewel-sets prelim)
         for residual = (stuff-jewels-fast prelim-holes base-list)
         when (not (equal residual '(0 0 0)))
         do ;; (when (and (= (split-env-target-id env) 121)
            ;;            (equal prelim-holes '(2 2 1)))
            ;;   (format t "~a~%" prelim-holes)
            ;;   (format t "~a~%" (loop for x in base-list collect (jewel-holes (aref *jewels* x)))))
           ;; (when (= (split-env-target-id env) 43)
           ;;   (format t "~a~%" prelim-holes)
           ;;   (format t "~a~%" (loop for x in base-list collect x))
           ;;   (format t "~a~%" (loop for x in base-list collect (jewel-holes (aref *jewels* x)))))
           (let* ((base-key (funcall (split-env-encoder env)
  				    base-list))
  		 (cands (funcall (split-env-hole-query env)
  				 (encode-hole-sig residual))))
  	    ;; (when trace-signal
  	    ;;   (format t "cands: ~a~%" (length cands)))
  	    (loop 
  	       for cand in cands
  	       for jewels-key = (encoded-skill-+ base-key
  
negative.code: 	       			     result)))))	
      result))
  
  (defun extra-skill-split-new (prelim env)
    (let* ((n (split-env-n env))
  	 (target-points (split-env-target-points env))
  