anchor.diff:  
   ;; I sure hope so...
   (setf (fdefinition 'stable-sort) #'sort)
  -;; missing function...
  -(setf (fdefinition 'delete-duplicates) #'remove-duplicates)
   
   (defun make-sequence (result-type size &key (initial-element nil initial-element-p))
     (cond ((subtypep result-type 'list)
  
positive.code: (defun delete-if-not (test sequence &key from-end (start 0) end count key)
    (remove-if-not test sequence :from-end from-end :start start :end end :count count :key key))
  
  (defun remove-duplicates (sequence &key from-end test test-not key) ; (start 0) end
    (check-test-test-not test test-not)
    (when test-not (setf test (complement test-not)))
    (unless test (setf test 'eql))
    (unless key (setf key 'identity))
    (etypecase sequence
      (list (if from-end
                (do* ((result (cons nil nil))
                      (tail result)
                      (i sequence (cdr i)))
                     ((null i)
                      (cdr result))
                  (unless (member (car i) (cdr result) :test test :key key)
                    (setf (cdr tail) (cons (car i) nil)
                          tail (cdr tail))))
                (do* ((result (cons nil nil))
                      (tail result)
                      (i sequence (cdr i)))
                     ((null i)
                      (cdr result))
                  (unless (member (car i) (cdr i) :test test :key key)
                    (setf (cdr tail) (cons (car i) nil)
                          tail (cdr tail))))))
      (vector
       (when from-end
         (setf sequence (reverse sequence)))
  
negative.code:          (setf result (nreverse result)))
         ;; Simplify result.
         (subseq result 0)))))
  
  (defun delete-duplicates (sequence &key from-end test test-not (start 0) end key)
    (remove-duplicates sequence
                       :from-end from-end
                       :test test
                       :test-not test-not
                       :start start
                       :end end
                       :key key))
  
  (defun subseq-list (sequence start end)
    ;; Seek in sequence
  