(defun fuzz (&key (length 100) (repetitions 1000000) (verbose t) (print-every 10000) (fiveamp nil))
  (flet ((random-vector (n)
           (let ((vector (make-array n :element-type '(unsigned-byte 2))))
             (dotimes (i n) (setf (aref vector i) (random 4)))
             vector))
         (random-boolean () (if (= 0 (random 2)) t nil)))
    (let ((failure-string nil)
          (predicate (lambda (x) (= x 0)))
          (predicate-not (lambda (x) (/= x 0))))
      (dotimes (i repetitions)
        (when (and verbose (= 0 (mod (1+ i) print-every)))
          (format t "Fuzz: Pass ~D passed.~%" (1+ i)))
        (let* ((length (1+ (random length)))
               (vector (random-vector length))
               (list (coerce vector 'list))
               (remove-empty-subseqs (random-boolean))
               (start 0) end from-end count)
          (case (random 5)
            (0)
            (1 (setf start (random length)))
            (2 (setf start (random length)
                     end (+ start (random (1+ (- length start))))))
            (3 (setf start (random length)
                     end (+ start (random (1+ (- length start))))
                     from-end t))
            (4 (setf start (random length)
                     end (+ start (random (1+ (- length start))))
                     from-end t
                     count (random (1+ (- end start))))))
          (let ((args (list :start start :end end :from-end from-end :count count
                            :remove-empty-subseqs remove-empty-subseqs)))
            (multiple-value-bind (expected-splits expected-index)
                (case (random 3)
                  (0 (apply #'split-sequence 0 vector args))
                  (1 (apply #'split-sequence-if predicate vector args))
                  (2 (apply #'split-sequence-if-not predicate-not vector args)))
              (multiple-value-bind (actual-splits actual-index)
                  (case (random 3)
                    (0 (apply #'split-sequence 0 list args))
                    (1 (apply #'split-sequence-if predicate list args))
                    (2 (apply #'split-sequence-if-not predicate-not list args)))
                (let* ((expected-splits (mapcar (lambda (x) (coerce x 'list)) expected-splits))
                       (result (and (equal actual-splits expected-splits)
                                    (= expected-index actual-index))))
                  (unless result
                    (let ((string (fuzz-failure
                                   vector start end from-end count remove-empty-subseqs
                                   expected-splits expected-index actual-splits actual-index)))
                      (cond (fiveamp
                             (setf failure-string string)
                             (return))
                            (t (assert result () string)))))))))))
      (when fiveamp
        (is (not failure-string) failure-string)))))