anchor.diff:                                                                  points)
                                        :forest forest
                                        :jewel-sets valid-sets))))))
  -
   
   (defun make-extra-skill-emitter (input required-effects n)
     (let* ((required-ids (mapcar #`,(first x1) (first-n required-effects (1+ n))))
  
positive.code:                                            :right right-val)))
  	result)))
  
  ;; (defun extra-skill-split (prelim env)
  ;;   (let* ((n (split-env-n env))
  ;; 	 (target-points (split-env-target-points env))
  ;; 	 (prelim-key (the (unsigned-byte 64)
  ;; 			  (preliminary-key prelim)))
  ;; 	 (jewel-cands (loop for cand in 
  ;; 			   (funcall (split-env-hole-query env)
  ;; 				    (hole-part prelim-key))
  ;; 			 when (is-satisfied-skill-key 
  ;; 			       (encoded-skill-+ 
  ;; 				(keyed-jewel-set-key cand)
  ;; 				(split-env-inv-req-key env)
  ;; 				prelim-key)
  ;; 			       (split-env-satisfy-mask env))
  ;; 			 collect cand))
  ;; 	 (minimum (- target-points
  ;; 		     (loop for cand in jewel-cands
  ;; 			maximize (decode-skill-sig-at 
  ;; 				  (keyed-jewel-set-key cand)
  ;; 				  n)))))
  ;;     (when (and jewel-cands
  ;;                (>= 
  ;;                    minimum))
  ;;       (let ((armor-cands (split-forest-at-skill
  ;;                           (preliminary-forest prelim)
  ;;                           (split-env-target-id env)
  ;;                           minimum)))
  ;;         (loop for (points forest) on (first armor-cands) by #'cddr
  ;;            ;; for points being the hash-keys of armor-cands
  ;;            ;; for forest being the hash-values of armor-cands
  ;;            for valid-sets = (loop for item in jewel-cands
  ;;                                when (>= (+ points
  ;;                                            (decode-skill-sig-at
  ;;                                             (keyed-jewel-set-key item)
  ;;                                             n))
  ;;                                         target-points)
  ;;                                append (keyed-jewel-set-set item))
  ;;            when valid-sets
  ;;            collect (make-preliminary :key (replace-skill-key-at prelim-key
  ;;                                                                 n
  ;;                                                                 points)
  ;;                                      :forest forest
  ;;                                      :jewel-sets valid-sets))))))
  
  (defun expand-jewel-candidates (prelim env)
    #f3
    (let* (result
  
negative.code: 			  (split-env-inv-req-key env)))
  	 (prelim-holes (decode-hole-sig (hole-part prelim-key))))
      (declare (type (unsigned-byte 64) prelim-key))
      (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 (let* ((base-key (funcall (split-env-encoder env)
  				    base-list))
  		 (cands (funcall (split-env-hole-query env)
  				 (encode-hole-sig residual))))
  	    (loop 
  	       for cand in cands
  	       for jewels-key = (encoded-skill-+ base-key
  