anchor.diff:                               (list :test-not test-not))
                              (when key-supplied
                                (list :key key)))))
  -    (unless end (setq end len))
  +    (unless end (setf end len))
       (if from-end
  -        (loop for right = end then left
  -              for left = (max (or (apply #'position delimiter seq
  -					 :end right
  -					 :from-end t
  -					 other-keys)
  -				  -1)
  -			      (1- start))
  -              unless (and (= right (1+ left))
  -                          remove-empty-subseqs) ; empty subseq we don't want
  -              if (and count (>= nr-elts count))
  -              ;; We can't take any more. Return now.
  -              return (values (nreverse subseqs) right)
  -              else
  -              collect (subseq seq (1+ left) right) into subseqs
  -              and sum 1 into nr-elts
  -              until (< left start)
  -              finally (return (values (nreverse subseqs) (1+ left))))
  -      (loop for left = start then (+ right 1)
  -            for right = (min (or (apply #'position delimiter seq
  -					:start left
  -					other-keys)
  -				 len)
  -			     end)
  -            unless (and (= right left)
  -                        remove-empty-subseqs) ; empty subseq we don't want
  -            if (and count (>= nr-elts count))
  -            ;; We can't take any more. Return now.
  -            return (values subseqs left)
  -            else
  -            collect (subseq seq left right) into subseqs
  -            and sum 1 into nr-elts
  -            until (>= right end)
  -            finally (return (values subseqs right))))))
  +        (split-from-end #'position delimiter seq other-keys
  +                        start end count remove-empty-subseqs)
  +        (split-from-start #'position delimiter seq len other-keys
  +                          start end count remove-empty-subseqs))))
   
  -(defun split-sequence-if (predicate seq &key (count nil) (remove-empty-subseqs nil) (from-end nil) (start 0) (end nil) (key nil key-supplied))
  +(defun split-sequence-if (predicate seq &key (start 0) (end nil) (from-end nil)
  +                          (count nil) (remove-empty-subseqs nil) (key nil key-supplied))
     "Return a list of subsequences in seq delimited by items satisfying
   predicate.
   
  
positive.code: argument to CL:SUBSEQ into the sequence indicating where processing
  stopped."
    (let ((len (length seq))
  	(other-keys (when key-supplied
  		      (list :key key))))
      (unless end (setq end len))
      (if from-end
          (loop for right = end then left
                for left = (max (or (apply #'position-if-not predicate seq
  					 :end right
  					 :from-end t
  					 other-keys)
  				  -1)
  			      (1- start))
                unless (and (= right (1+ left))
                            remove-empty-subseqs) ; empty subseq we don't want
                if (and count (>= nr-elts count))
                ;; We can't take any more. Return now.
                return (values (nreverse subseqs) right)
                else
                collect (subseq seq (1+ left) right) into subseqs
                and sum 1 into nr-elts
                until (< left start)
                finally (return (values (nreverse subseqs) (1+ left))))
        (loop for left = start then (+ right 1)
              for right = (min (or (apply #'position-if-not predicate seq
  					:start left
  					other-keys)
  				 len)
  			     end)
              unless (and (= right left)
                          remove-empty-subseqs) ; empty subseq we don't want
              if (and count (>= nr-elts count))
              ;; We can't take any more. Return now.
              return (values subseqs left)
              else
              collect (subseq seq left right) into subseqs
              and sum 1 into nr-elts
              until (>= right end)
              finally (return (values subseqs right))))))
  
negative.code: stopped."
    (let ((len (length seq))
          (other-keys (when key-supplied
                        (list :key key))))
      (unless end (setf end len))
      (if from-end
          (split-from-end #'position-if predicate seq other-keys
                          start end count remove-empty-subseqs)
          (split-from-start #'position-if predicate seq len other-keys
                            start end count remove-empty-subseqs))))
  
  (defun split-sequence-if-not (predicate seq &key (count nil) (remove-empty-subseqs nil)
                                (from-end nil) (start 0) (end nil) (key nil key-supplied))
    "Return a list of subsequences in seq delimited by items satisfying
  \(CL:COMPLEMENT predicate).
  
  