anchor.diff:  		      prelim-inv-key
   		      jewels-key)
   		     (split-env-satisfy-mask env))
  -	       do (incf *counter-0*)
  -		 (setf result (cons (make-keyed-jewel-set 
  +	       do (setf result (cons (make-keyed-jewel-set 
   	       			      :key jewels-key
   	       			      :set (mapcar (lambda (x) 
   	       					     (append x base-list))
  
positive.code:     (when jewel-cands
  	       ;; (<= minimum (max-at-skill (preliminary-forest prelim)
  	       ;; 				 (split-env-target-id env))))
        (incf *counter-1*)
        (let ((armor-cands (split-forest-at-skill
                            (preliminary-forest prelim)
                            (split-env-target-id env)
  
negative.code:   (target-points 0)
    (inv-req-key 0)
    (satisfy-mask 0)
    (forest-maximizer nil)
    (n 0))
  
  (defun max-at-skill-client (target-id)
    #f3
    (let ((store (make-array '(7 400) :element-type 'fixnum :initial-element 0)))
      (declare (type (simple-array fixnum (7 400)) store))
      (loop for part-list in (list *helms* *cuirasses* *gloves* 
                                   *cuisses* *sabatons*)
         do (loop for item across part-list
               do (setf (aref store (armor-part-id item) (armor-id item))
                        (the fixnum (points-of-skill item target-id)))))
      (labels ((client (forest)
                 (if (armor-p (car forest))
                     ;; case 1: last level
                     (the fixnum (loop for item in forest
                                    maximize (aref store 
                                                   (armor-part-id item)
                                                   (armor-id item))))
                     ;; case 2 middle levels
                     (the fixnum 
                          (loop for tree in forest
                             maximize (+ (the fixnum 
                                              (loop for item in (armor-tree-left tree)
                                                 maximize (aref store 
                                                                (armor-part-id item)
                                                                (armor-id item))))
                                         (client (armor-tree-right tree))))))))
        #'client)))
  
  (defun split-forest-at-skill (forest target-id minimum)
    ;; The parameter FOREST is a little bit misleading, as it
  