anchor.diff:  
   (defmethod %set-filter-range ((client sphinx-client) type attr min max &key (exclude nil))
     (assert (and (numberp min) (numberp max) (>= max min)))
  -  (push '(type attr min max (cond (exclude 1) (t 0))) (filters client))
  +  (push `(,type ,attr ,min ,max ,(cond (exclude 1) (t 0))) (filters client))
     client)
   
   ;;   (let ((filter (make-hash-table)))
  
positive.code: ;;;; See the LICENSE file for licensing information.
  
  (in-package #:cl-sphinx-search)
  
  
  (defvar *response-length* ())
  
negative.code:                      (concatenate 'string
                                    (pack "N/a*" attr)
                                    (pack "N" type)
                                    (cond ((eql type +sph-filter-values+)
                                           (%pack-list-signed-quads (third filter)))
                                          ((eql type +sph-filter-range+)
                                           (concatenate 'string
                                                        (pack "q>" (third filter))
                                                        (pack "q>" (fourth filter))))
                                          ((eql type +sph-filter-floatrange+)
                                           (concatenate 'string
                                                        (%pack-float (third filter))
                                                        (%pack-float (fourth filter))))
                                          (t
                                           (error "Unhandled filter type ~S" type)))
                                    (pack "N" (last filter)))))
         filters))
  
  
  ;;                    (when (hash-table-p filter)
  ;;                      (concatenate 'string
  ;;                                   (pack "N/a*" (gethash 'attr filter))
  ;;                                   (let ((type (gethash 'type filter)))
  ;;                                     (concatenate 'string
  ;;                                                  (pack "N" type)
  
  
  (defun %pack-hash (hash-table)
  