HOME

;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\301\302!B\301\207" [package--builtin-versions purecopy (cl-generic 1 0)] 2)
#@82 compiler-macro for inlining `cl--generic-generalizer-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-generalizer-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-p (and (memq (type-of cl-x) cl-struct-cl--generic-generalizer-tags) t)) nil] 9 (#$ . 499)])
(put 'cl--generic-generalizer-p 'compiler-macro 'cl--generic-generalizer-p--cmacro)
#@13 

(fn CL-X)
(defalias 'cl--generic-generalizer-p #[257 "\301
!>\205	\302\207" [cl-struct-cl--generic-generalizer-tags type-of t] 3 (#$ . 910)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put cl--generic-generalizer-p side-effect-free error-free put cl--generic-generalizer cl-deftype-satisfies] 5)
#@85 compiler-macro for inlining `cl--generic-generalizer-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-generalizer-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-name (or (cl--generic-generalizer-p cl-x) (signal 'wrong-type-argument (list 'cl--generic-generalizer cl-x))) (aref cl-x 1)) nil] 9 (#$ . 1235)])
(put 'cl--generic-generalizer-name 'compiler-macro 'cl--generic-generalizer-name--cmacro)
#@192 Access slot "name" of `(cl--generic-generalizer (:constructor nil) (:constructor cl-generic-make-generalizer (name priority tagcode-function specializers-function)))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-generalizer-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-generalizer-tags type-of signal wrong-type-argument cl--generic-generalizer 1] 5 (#$ . 1713)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--generic-generalizer-name side-effect-free t] 4)
#@89 compiler-macro for inlining `cl--generic-generalizer-priority'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-generalizer-priority--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-priority (or (cl--generic-generalizer-p cl-x) (signal 'wrong-type-argument (list 'cl--generic-generalizer cl-x))) (aref cl-x 2)) nil] 9 (#$ . 2229)])
(put 'cl--generic-generalizer-priority 'compiler-macro 'cl--generic-generalizer-priority--cmacro)
#@196 Access slot "priority" of `(cl--generic-generalizer (:constructor nil) (:constructor cl-generic-make-generalizer (name priority tagcode-function specializers-function)))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-generalizer-priority #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-generalizer-tags type-of signal wrong-type-argument cl--generic-generalizer 2] 5 (#$ . 2727)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--generic-generalizer-priority side-effect-free t] 4)
#@97 compiler-macro for inlining `cl--generic-generalizer-tagcode-function'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-generalizer-tagcode-function--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-tagcode-function (or (cl--generic-generalizer-p cl-x) (signal 'wrong-type-argument (list 'cl--generic-generalizer cl-x))) (aref cl-x 3)) nil] 9 (#$ . 3255)])
(put 'cl--generic-generalizer-tagcode-function 'compiler-macro 'cl--generic-generalizer-tagcode-function--cmacro)
#@204 Access slot "tagcode-function" of `(cl--generic-generalizer (:constructor nil) (:constructor cl-generic-make-generalizer (name priority tagcode-function specializers-function)))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-generalizer-tagcode-function #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-generalizer-tags type-of signal wrong-type-argument cl--generic-generalizer 3] 5 (#$ . 3793)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--generic-generalizer-tagcode-function side-effect-free t] 4)
#@102 compiler-macro for inlining `cl--generic-generalizer-specializers-function'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-generalizer-specializers-function--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-generalizer-specializers-function (or (cl--generic-generalizer-p cl-x) (signal 'wrong-type-argument (list 'cl--generic-generalizer cl-x))) (aref cl-x 4)) nil] 9 (#$ . 4346)])
(put 'cl--generic-generalizer-specializers-function 'compiler-macro 'cl--generic-generalizer-specializers-function--cmacro)
#@209 Access slot "specializers-function" of `(cl--generic-generalizer (:constructor nil) (:constructor cl-generic-make-generalizer (name priority tagcode-function specializers-function)))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-generalizer-specializers-function #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-generalizer-tags type-of signal wrong-type-argument cl--generic-generalizer 4] 5 (#$ . 4909)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put cl--generic-generalizer-specializers-function side-effect-free t defalias copy-cl--generic-generalizer copy-sequence] 4)
#@132 compiler-macro for inlining `cl-generic-make-generalizer'.

(fn CL-WHOLE-ARG NAME PRIORITY TAGCODE-FUNCTION SPECIALIZERS-FUNCTION)
(defalias 'cl-generic-make-generalizer--cmacro #[1285 "\300\301\302\303\211\211				&	\207" [cl--defsubst-expand (name priority tagcode-function specializers-function) (cl-block cl-generic-make-generalizer (record 'cl--generic-generalizer name priority tagcode-function specializers-function)) nil] 15 (#$ . 5539)])
(put 'cl-generic-make-generalizer 'compiler-macro 'cl-generic-make-generalizer--cmacro)
#@119 Constructor for objects of type `cl--generic-generalizer'.

(fn NAME PRIORITY TAGCODE-FUNCTION SPECIALIZERS-FUNCTION)
(defalias 'cl-generic-make-generalizer #[1028 "\300\301%\207" [record cl--generic-generalizer] 10 (#$ . 6084)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put cl-generic-make-generalizer side-effect-free t cl-struct-define cl--generic-generalizer nil cl-structure-object record ((cl-tag-slot) (name nil :type string) (priority nil :type integer) (tagcode-function) (specializers-function)) cl-struct-cl--generic-generalizer-tags] 11)
#@650 Define a new kind of generalizer.
NAME is the name of the variable that will hold it.
PRIORITY defines which generalizer takes precedence.
  The catch-all generalizer has priority 0.
  Then `eql' generalizer has priority 100.
TAGCODE-FUNCTION takes as first argument a varname and should return
  a chunk of code that computes the tag of the value held in that variable.
  Further arguments are reserved for future use.
SPECIALIZERS-FUNCTION takes as first argument a tag value TAG
  and should return a list of specializers that match TAG.
  Further arguments are reserved for future use.

(fn NAME PRIORITY TAGCODE-FUNCTION SPECIALIZERS-FUNCTION)
(defalias 'cl-generic-define-generalizer '(macro . #[1028 "\300\301\302D\257E\207" [defconst cl-generic-make-generalizer quote] 11 (#$ . 6691)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-generic-define-generalizer lisp-indent-function 1 put edebug-form-spec (symbolp body)] 5)
(defconst cl--generic-t-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\207" [nil] 3 "\n\n(fn NAME &rest _)"] #[385 "\300\207" [(t)] 3 "\n\n(fn TAG &rest _)"] record cl--generic-generalizer cl--generic-t-generalizer 0] 8))
#@88 compiler-macro for inlining `cl--struct-cl--generic-method-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--struct-cl--generic-method-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--struct-cl--generic-method-p (and (memq (type-of cl-x) cl-struct-cl--generic-method-tags) t)) nil] 9 (#$ . 7906)])
(put 'cl--struct-cl--generic-method-p 'compiler-macro 'cl--struct-cl--generic-method-p--cmacro)
#@13 

(fn CL-X)
(defalias 'cl--struct-cl--generic-method-p #[257 "\301
!>\205	\302\207" [cl-struct-cl--generic-method-tags type-of t] 3 (#$ . 8343)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put cl--struct-cl--generic-method-p side-effect-free error-free put cl--generic-method cl-deftype-satisfies] 5)
#@88 compiler-macro for inlining `cl--generic-method-specializers'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-method-specializers--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-specializers (or (cl--struct-cl--generic-method-p cl-x) (signal 'wrong-type-argument (list 'cl--generic-method cl-x))) (aref cl-x 1)) nil] 9 (#$ . 8671)])
(put 'cl--generic-method-specializers 'compiler-macro 'cl--generic-method-specializers--cmacro)
#@197 Access slot "specializers" of `(cl--generic-method (:constructor nil) (:constructor cl--generic-make-method (specializers qualifiers uses-cnm function)) (:predicate nil))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-method-specializers #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-method-tags type-of signal wrong-type-argument cl--generic-method 1] 5 (#$ . 9165)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put cl--generic-method-specializers side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-method-specializers] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@86 compiler-macro for inlining `cl--generic-method-qualifiers'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-method-qualifiers--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-qualifiers (or (cl--struct-cl--generic-method-p cl-x) (signal 'wrong-type-argument (list 'cl--generic-method cl-x))) (aref cl-x 2)) nil] 9 (#$ . 9828)])
(put 'cl--generic-method-qualifiers 'compiler-macro 'cl--generic-method-qualifiers--cmacro)
#@195 Access slot "qualifiers" of `(cl--generic-method (:constructor nil) (:constructor cl--generic-make-method (specializers qualifiers uses-cnm function)) (:predicate nil))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-method-qualifiers #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-method-tags type-of signal wrong-type-argument cl--generic-method 2] 5 (#$ . 10312)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put cl--generic-method-qualifiers side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-method-qualifiers] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@84 compiler-macro for inlining `cl--generic-method-uses-cnm'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-method-uses-cnm--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-uses-cnm (or (cl--struct-cl--generic-method-p cl-x) (signal 'wrong-type-argument (list 'cl--generic-method cl-x))) (aref cl-x 3)) nil] 9 (#$ . 10968)])
(put 'cl--generic-method-uses-cnm 'compiler-macro 'cl--generic-method-uses-cnm--cmacro)
#@193 Access slot "uses-cnm" of `(cl--generic-method (:constructor nil) (:constructor cl--generic-make-method (specializers qualifiers uses-cnm function)) (:predicate nil))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-method-uses-cnm #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-method-tags type-of signal wrong-type-argument cl--generic-method 3] 5 (#$ . 11443)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put cl--generic-method-uses-cnm side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-method-uses-cnm] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@84 compiler-macro for inlining `cl--generic-method-function'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-method-function--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-function (or (cl--struct-cl--generic-method-p cl-x) (signal 'wrong-type-argument (list 'cl--generic-method cl-x))) (aref cl-x 4)) nil] 9 (#$ . 12091)])
(put 'cl--generic-method-function 'compiler-macro 'cl--generic-method-function--cmacro)
#@193 Access slot "function" of `(cl--generic-method (:constructor nil) (:constructor cl--generic-make-method (specializers qualifiers uses-cnm function)) (:predicate nil))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-method-function #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-method-tags type-of signal wrong-type-argument cl--generic-method 4] 5 (#$ . 12566)])
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\"\207" [function-put cl--generic-method-function side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-method-function] 5 "\n\n(fn CL-DO CL-X)"] defalias copy-cl--generic-method copy-sequence] 5)
#@117 compiler-macro for inlining `cl--generic-make-method'.

(fn CL-WHOLE-ARG SPECIALIZERS QUALIFIERS USES-CNM FUNCTION)
(defalias 'cl--generic-make-method--cmacro #[1285 "\300\301\302\303\211\211				&	\207" [cl--defsubst-expand (specializers qualifiers uses-cnm function) (cl-block cl--generic-make-method (record 'cl--generic-method specializers qualifiers uses-cnm function)) nil] 15 (#$ . 13272)])
(put 'cl--generic-make-method 'compiler-macro 'cl--generic-make-method--cmacro)
#@103 Constructor for objects of type `cl--generic-method'.

(fn SPECIALIZERS QUALIFIERS USES-CNM FUNCTION)
(defalias 'cl--generic-make-method #[1028 "\300\301%\207" [record cl--generic-method] 10 (#$ . 13760)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put cl--generic-make-method side-effect-free t cl-struct-define cl--generic-method nil cl-structure-object record ((cl-tag-slot) (specializers nil :read-only t :type list) (qualifiers nil :read-only t :type (list-of atom)) (uses-cnm nil :read-only t :type boolean) (function nil :read-only t :type function)) cl-struct-cl--generic-method-tags] 11)
#@81 compiler-macro for inlining `cl--struct-cl--generic-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--struct-cl--generic-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--struct-cl--generic-p (and (memq (type-of cl-x) cl-struct-cl--generic-tags) t)) nil] 9 (#$ . 14411)])
(put 'cl--struct-cl--generic-p 'compiler-macro 'cl--struct-cl--generic-p--cmacro)
#@13 

(fn CL-X)
(defalias 'cl--struct-cl--generic-p #[257 "\301
!>\205	\302\207" [cl-struct-cl--generic-tags type-of t] 3 (#$ . 14807)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put cl--struct-cl--generic-p side-effect-free error-free put cl--generic cl-deftype-satisfies] 5)
#@73 compiler-macro for inlining `cl--generic-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-name (or (cl--struct-cl--generic-p cl-x) (signal 'wrong-type-argument (list 'cl--generic cl-x))) (aref cl-x 1)) nil] 9 (#$ . 15108)])
(put 'cl--generic-name 'compiler-macro 'cl--generic-name--cmacro)
#@138 Access slot "name" of `(cl--generic (:constructor nil) (:constructor cl--generic-make (name)) (:predicate nil))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags type-of signal wrong-type-argument cl--generic 1] 5 (#$ . 15514)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put cl--generic-name side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" cl--generic-name] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@79 compiler-macro for inlining `cl--generic-dispatches'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-dispatches--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-dispatches (or (cl--struct-cl--generic-p cl-x) (signal 'wrong-type-argument (list 'cl--generic cl-x))) (aref cl-x 2)) nil] 9 (#$ . 16060)])
(put 'cl--generic-dispatches 'compiler-macro 'cl--generic-dispatches--cmacro)
#@144 Access slot "dispatches" of `(cl--generic (:constructor nil) (:constructor cl--generic-make (name)) (:predicate nil))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-dispatches #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags type-of signal wrong-type-argument cl--generic 2] 5 (#$ . 16496)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--generic-dispatches side-effect-free t] 4)
#@81 compiler-macro for inlining `cl--generic-method-table'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-method-table--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-method-table (or (cl--struct-cl--generic-p cl-x) (signal 'wrong-type-argument (list 'cl--generic cl-x))) (aref cl-x 3)) nil] 9 (#$ . 16929)])
(put 'cl--generic-method-table 'compiler-macro 'cl--generic-method-table--cmacro)
#@146 Access slot "method-table" of `(cl--generic (:constructor nil) (:constructor cl--generic-make (name)) (:predicate nil))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-method-table #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags type-of signal wrong-type-argument cl--generic 3] 5 (#$ . 17375)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--generic-method-table side-effect-free t] 4)
#@76 compiler-macro for inlining `cl--generic-options'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--generic-options--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--generic-options (or (cl--struct-cl--generic-p cl-x) (signal 'wrong-type-argument (list 'cl--generic cl-x))) (aref cl-x 4)) nil] 9 (#$ . 17814)])
(put 'cl--generic-options 'compiler-macro 'cl--generic-options--cmacro)
#@141 Access slot "options" of `(cl--generic (:constructor nil) (:constructor cl--generic-make (name)) (:predicate nil))' struct CL-X.

(fn CL-X)
(defalias 'cl--generic-options #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags type-of signal wrong-type-argument cl--generic 4] 5 (#$ . 18235)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put cl--generic-options side-effect-free t defalias copy-cl--generic copy-sequence] 4)
#@73 compiler-macro for inlining `cl--generic-make'.

(fn CL-WHOLE-ARG NAME)
(defalias 'cl--generic-make--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (name) (cl-block cl--generic-make (record 'cl--generic name nil nil nil)) nil] 9 (#$ . 18709)])
(put 'cl--generic-make 'compiler-macro 'cl--generic-make--cmacro)
#@59 Constructor for objects of type `cl--generic'.

(fn NAME)
(defalias 'cl--generic-make #[257 "\300\301\302\211\211%\207" [record cl--generic nil] 7 (#$ . 19047)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put cl--generic-make side-effect-free t cl-struct-define cl--generic nil cl-structure-object record ((cl-tag-slot) (name nil :type symbol :read-only t) (dispatches nil :type (list-of (cons natnum (list-of generalizers)))) (method-table nil :type (list-of cl--generic-method)) (options nil :type list)) cl-struct-cl--generic-tags] 11)
#@67 Return the options of the generic function GENERIC.

(fn GENERIC)
(defalias 'cl-generic-function-options #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--generic-tags type-of signal wrong-type-argument cl--generic 4] 5 (#$ . 19637)])
#@13 

(fn NAME)
(defalias 'cl--generic '(macro . #[257 "\300
\301BB\207" [get ('cl--generic)] 4 (#$ . 19899)]))
#@52 Return non-nil if F is a generic function.

(fn F)
(defalias 'cl-generic-p #[257 "\2119\205\211\300N\207" [cl--generic] 3 (#$ . 20013)])
#@31 

(fn NAME &optional NOERROR)
(defalias 'cl-generic-ensure-function #[513 "\301\302N\211\262\204\"\303!\203\"\204\"K9\203\"K\262\202\303!\203FK\211\242\304=\262
\204F\305!\203=
\204F\204F\306\307\"\210
\203h\310!>\204Z\311\312\302D\"\210\313H=\204z\314\315!\210\202z\316
\302\317\302	\301\211\211%\211\262#\266
\207" [cl-struct-cl--generic-tags nil cl--generic fboundp autoload functionp error "%s is already defined as something else than a generic function" type-of signal wrong-type-argument 1 cl--assertion-failed (eq name (cl--generic-name generic)) put record] 14 (#$ . 20158)])
#@619 Create a generic function NAME.
DOC-STRING is the base documentation for this class.  A generic
function has no body, as its purpose is to decide which method body
is appropriate to use.  Specific methods are defined with `cl-defmethod'.
With this implementation the ARGS are currently ignored.
OPTIONS-AND-METHODS currently understands:
- (:documentation DOCSTRING)
- (declare DECLARATIONS)
- (:argument-precedence-order &rest ARGS)
- (:method [QUALIFIERS...] ARGS &rest BODY)
DEFAULT-BODY, if present, is used as the body of a default method.

(fn NAME ARGS [DOC-STRING] [OPTIONS-AND-METHODS...] &rest DEFAULT-BODY)
(defalias 'cl-defgeneric '(macro . #[642 "C
\242;\205
\211A\262\242\300\211\211\211@\242\262
\301
!\204$\211\302=\203w\211\303\267\202i\2035\304\305\242\"\210\211A\262\242A@\262\202\203N\304\306\242\"\210\211A\262\242\262\202\211A\262\242AB\262\202\211A\262\242B\262\202\203\205BB\262\242\242\307=\203\233\310\311!\210\312\242A@!\240\210\313\314\315\316	\242D\317\316\242D\316D\316	\237DF\320\n\"F\321\322\323\324\325\326\327!\330\"\331\332%\237\"BBB\322\323\324\333\326\327
\"\334\"\335\336%A\"BB\266\205\207" [nil keywordp declare #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:documentation 42 declare 67 :method 90)) error "Multiple doc strings for %S" "Multiple `declare' for %S" setf require gv gv-setter prog1 progn defalias quote cl-generic-define help-add-fundoc-usage :autoload-end mapcar make-byte-code 257 "\301\300\242BB\207" vconcat vector [cl-defmethod] 4 "\n\n(fn METHOD)" "\211@\n\236A\211\203\303
@\300\242\301A$\202\304\305@\300\242#\210\306\207" [defun-declarations-alist apply message "Warning: Unknown defun property `%S' in %S" nil] 7 "\n\n(fn DECLARATION)"] 20 (#$ . 20787)]))
(byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put cl-defgeneric lisp-indent-function 2 doc-string-elt 3 put edebug-form-spec (&define [&or name ("setf" name :name setf)] listp lambda-doc [&rest [&or ("declare" &rest sexp) (":argument-precedence-order" &rest sexp) (&define ":method" [&rest atom] cl-generic-method-args lambda-doc def-body)]] def-body)] 6)
#@26 

(fn NAME ARGS OPTIONS)
(defalias 'cl-generic-define #[771 "\301\302\"\303!\211@\211\304\305\"\306\236\307	!\204I\310!>\204*\311\312\313D\"\210\211\314\315I\266\310!>\204B\311\312\313D\"\210\211\316\315I\266\211\203\252\211A\211\203\251\211@\211>\211\204a\317\320\"\210G
GZ\310\n!>\204w\311\312\313\fD\"\210	\314H

\236\206\203
C\310\f!>\204\224\311\312\313D\"\210\211\314\321\"BI\266
A\266\202\202O\210\310!>\204\273\311\312\313D\"\210\211\322	I\266\323!\266\202\262
\207" [cl-struct-cl--generic-tags cl-generic-ensure-function noerror cl--generic-split-args mapcar car :argument-precedence-order fboundp type-of signal wrong-type-argument cl--generic 2 nil 3 error "%S is not a mandatory argument" delq 4 cl--generic-make-function] 22 (#$ . 23023)])
#@132 List of (VAR . TYPE) where TYPE is var's specializer.
This macro can only be used within the lexical scope of a cl-generic method.
(defalias 'cl-generic-current-method-specializers '(macro . #[0 "\300\301!\207" [error "cl-generic-current-method-specializers used outside of a method"] 2 (#$ . 23842)]))
#@194 Define a special kind of context named NAME.
Whenever a context specializer of the form (NAME . ARGS) appears,
the specializer used will be the one returned by BODY.

(fn NAME ARGS &rest BODY)
(defalias 'cl-generic-define-context-rewriter '(macro . #[642 "\300\301\302D\303\304BBFD\207" [eval-and-compile put quote 'cl-generic--context-rewriter lambda] 10 (#$ . 24152)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put cl-generic-define-context-rewriter edebug-form-spec (&define name lambda-list def-body) function-put lisp-indent-function defun] 4)
#@65 Check which of the symbols VARS appear in SEXP.

(fn VARS SEXP)
(defalias 'cl--generic-fgrep #[514 "\300
:\203+\301\211A\262\242\"\211\203'\211@\211>\204 \211B\262
A\266\202\202\210\202

>\203<

>\204<

B\262
\211\207" [nil cl--generic-fgrep] 7 (#$ . 24732)])
#@45 Return (SPEC-ARGS . PLAIN-ARGS).

(fn ARGS)
(defalias 'cl--generic-split-args #[257 "\300\211\301\211\203\231\211@\211\302>\203\300\262\211\202\216\211\303=\203,\204%\304\305!\210\306\262\300\202\216\2044\211\202\216\306=\203k\211:\204D\304\307\"\210\211@\2119\205N\211\310N\211\203Y\311
A\"\262\266\303
@B
A@BB\262\300\202\216\211:\203\206\211@
A\211\211@BB\262\262
\266\202\202\216\211\301BB\262\211B\262
A\266\202\202\210
\237\312\300\"\237B\207" [nil t (&key &rest &optional) &context error "&context not immediately after mandatory args" context "Invalid &context arg: %S" cl-generic--context-rewriter apply delq] 12 (#$ . 25013)])
#@77 Make the lambda expression for a method with ARGS and BODY.

(fn ARGS BODY)
(defalias 'cl--generic-lambda #[514 "\301!\211@
A\211\302\303BBD\304\305\306\307\310\311!\312\"\313$BB\314\315!\210\316\"\211:\203
\211@\211\317=\203\370
A\211:\203\354\211@\211:\203\340\211@\211\303=\203\324
A\211:\203\310\211@
AA\211\204\273
\320!\321\322!\321\323!\324\325\326D\327DDABB\"\330D\"\211??\317\303\331\205\213C\n\"\331	@>\204\237\202\256\332	\303\333\334DEDC	EC\"BBDB\266\205\266\202\202\303\335\336\"\262
\266\203\202\317\335\336\"\262
\262
\202\333\335\336\"\262
\262
\202\347\335\336\"\262
\262
\202\363\335\336\"\262
\262
\202\377
\335\336\"\262
\262
\202
\211\335\336\"\262
\262
\266\202\266\202\207" [macroexpand-all-environment cl--generic-split-args cl-function lambda cl-generic-current-method-specializers make-byte-code 0 "\300\207" vconcat vector [] 1 require cl-lib macroexpand function macroexp-parse-body make-symbol "cl--cnm" "cl--nmp" macroexpand-all cl-flet cl-call-next-method cl-next-method-p cl--generic-fgrep append let nil cl--generic-isnot-nnm-p error "Unexpected macroexpansion result: %S"] 37 (#$ . 25696)])
(put 'cl-defmethod 'function-documentation '(cl--generic-make-defmethod-docstring))
(defalias 'cl--generic-make-defmethod-docstring #[0 "\301\302K\303\"\304
\302\"\305\306!\210\307\310!r\211q\210\311\312\313\314\315!\316\"\317$\216
A\206&c\210\320c\210\321\322\323N\324
!>\204>\325\326\323D\"\210\211\327H\262
!\211\203b\211@\330
!\317
8\203Z\317
8\331\261\210\210
A\266\202\202D\210\332 \203q\333
@\"\202r\211\262
*\262
\207" [cl-struct-cl--generic-tags documentation cl-defmethod raw help-split-fundoc require help-fns generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n	Currently supported forms for TYPE:\n\n" reverse cl-generic-generalizers cl--generic type-of signal wrong-type-argument 3 cl--generic-method-info "\n\n" buffer-string help-add-fundoc-usage] 9])
#@1443 Define a new method for generic function NAME.
I.e. it defines the implementation of NAME to use for invocations where the
values of the dispatch arguments match the specified TYPEs.
The dispatch arguments have to be among the mandatory arguments, and
all methods of NAME have to use the same set of arguments for dispatch.
Each dispatch argument and TYPE are specified in ARGS where the corresponding
formal argument appears as (VAR TYPE) rather than just VAR.

The optional second argument QUALIFIER is a specifier that
modifies how the method is combined with other methods, including:
   :before  - Method will be called before the primary
   :after   - Method will be called after the primary
   :around  - Method will be called around everything else
The absence of QUALIFIER means this is a "primary" method.
The set of acceptable qualifiers and their meaning is defined
(and can be extended) by the methods of `cl-generic-combine-methods'.

ARGS can also include so-called context specializers, introduced by
`&context' (which should appear right after the mandatory arguments,
before any &optional or &rest).  They have the form (EXPR TYPE) where
EXPR is an Elisp expression whose value should match TYPE for the
method to be applicable.

The set of acceptable TYPEs (also called "specializers") is defined
(and can be extended) by the various methods of `cl-generic-generalizers'.

(fn NAME [QUALIFIER] ARGS &rest [DOCSTRING] BODY)
(defalias 'cl-defmethod '(macro . #[642 "\300<\204
B\262

\211A\262\242\262\202
\242\301=\203(\302\303!\210\304A@!\262\305\"\211@
A\211\306	\307N\205U\310\311!\203F\311\312!\205U	\307N\313\314\f\315#\300\"\262
\316\317BB\320\321
D\321\237D\321D	\257F\266\202\266\203\207" [nil setf require gv gv-setter cl--generic-lambda progn byte-obsolete-info fboundp byte-compile-warning-enabled-p obsolete macroexp--warn-and-return macroexp--obsolete-warning "generic function" declare-function ("") cl-generic-define-method quote] 18 (#$ . 27751)]))
(byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put cl-defmethod doc-string-elt 3 lisp-indent-function defun put edebug-form-spec (&define [&or name ("setf" name :name setf)] [&rest atom] cl-generic-method-args lambda-doc def-body)] 6)
#@40 

(fn SPECIALIZERS QUALIFIERS METHODS)
(defalias 'cl--generic-member-method #[771 "\211\203>\211@\301
!>\204\302\303\304D\"\210\211\305H\232\2051\301
!>\204,\302\303\304D\"\210\211\306H\232?\262
\203>\211A\262
\202\207" [cl-struct-cl--generic-method-tags type-of signal wrong-type-argument cl--generic-method 1 2] 8 (#$ . 30038)])
#@37 

(fn NAME QUALIFIERS SPECIALIZERS)
(defalias 'cl--generic-load-hist-format #[771 "BB\207" [] 6 (#$ . 30389)])
#@47 

(fn NAME QUALIFIERS ARGS USES-CNM FUNCTION)
(defalias 'cl-generic-define-method #[1285 "\303!\304!\211@\211\305\306\"\307\310\n\n%\311!>\204(\312\313\314D\"\210\315H\316\f#\311!>\204B\312\313\314\nD\"\210\317H\320\211\203\300\211@\211@\242\321=\203\\\211@\202]\322A!\323\"\211\204\220\322\324!B\262
\311!>\204\202\312\313\314D\"\210\211\317\nB\211\262I\266
\211\203\262\211@\211A\235\204\253\211\325AB\326\"\241\266
A\266\202\202\221\210T\262\266
A\266\202\202I\210\311\n!>\204\322\312\313\314\fD\"\210	\211\315\204\342B\202\365\305\327\330\331\332\333
\f\"\334\"\315\335%\"I\266\311\n!>\204	
\312\313\314\fD\"\210	\336H\211K\204
\337
\340\"\210\341\342\311
!>\204*
\312\313\314D\"\210\f\336H\n#B\211	\235\203>
	\202A
\211	B\262
\343!\344\211\337\"*\262
\262
\266\206\262
\207" [cl-struct-cl--generic-tags current-load-list purify-flag cl-generic-ensure-function cl--generic-split-args mapcar #[257 "\211@\242\300=\203	\207\211A\207" [&context] 3 "\n\n(fn SPEC-ARG)"] record cl--generic-method type-of signal wrong-type-argument cl--generic 3 cl--generic-member-method 2 0 &context cl-generic-generalizers assoc t sort #[514 "\301!>\204\302\303\304D\"\210
\305H\301!>\204!\302\303\304D\"\210
\305HV\207" [cl-struct-cl--generic-generalizer-tags type-of signal wrong-type-argument cl--generic-generalizer 2] 7 "\n\n(fn X Y)"] make-byte-code 257 "\211\301@=\203	\300\207\207" vconcat vector [] "\n\n(fn X)" 1 defalias dummy cl-defmethod cl--generic-load-hist-format cl--generic-make-function nil] 27 (#$ . 30509)])
#@25 

(fn PLACE &rest CODE)
(defalias 'cl--generic-with-memoization '(macro . #[385 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [gv-get make-byte-code 514 "\301\302\300!\303
!\203\211\202\304\305!\306!E
=\203\"\211\202)\307DC\"\266\203E\207" vconcat vector [or macroexp-progn macroexp-const-p make-symbol "val" progn macroexp-let*] 10 "\n\n(fn GETTER SETTER)"] 10 (#$ . 32139)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl--generic-with-memoization lisp-indent-function 1 put edebug-form-spec t] 5)
(defvar cl--generic-dispatchers (make-hash-table :test 'equal))
#@17 

(fn DISPATCH)
(defalias 'cl--generic-get-dispatcher #[257 "\211\302\"\206\256@A\303\304\305\"\304\306\"\307\310\311!@!\203'\312!\202(B\313\314\242\315=\203B\316ADC\262
\314\262\317\262
\317\211W\203c\211\320\321\322\323\324#\"!B\262\210\211T\262
\202D\266\325\326\327\330\331\326\332	\333\"\330\334\335\302\336BB\337\340\341D\342\343A\203\220\332B\202\223@\257E\332\344\"BBEEEE!)\266\210\345#\210\211\262
\207" [cl--generic-dispatchers lexical-binding gethash t mapcar #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306!\207" [cl-struct-cl--generic-generalizer-tags type-of signal wrong-type-argument cl--generic-generalizer 3 arg] 5 "\n\n(fn GENERALIZER)"] #[257 "\301\302\303!>\204\304\305\306D\"\210\307HD\303!>\204$\304\305\306D\"\210\310H\311!E\207" [cl-struct-cl--generic-generalizer-tags funcall quote type-of signal wrong-type-argument cl--generic-generalizer 4 3 arg] 7 "\n\n(fn GENERALIZER)"] or macroexp-const-p last butlast (arg) nil &context arg 0 make-symbol format "arg%d" - 1 byte-compile lambda (generic dispatches-left methods) let ((method-cache (make-hash-table :test #'eql))) append (&rest args) apply cl--generic-with-memoization (method-cache) cl--generic-cache-miss generic quote dispatches-left methods (args) puthash] 30 (#$ . 32752)])
#@16 

(fn GENERIC)
(defalias 'cl--generic-make-function #[257 "\301
\302!>\204\303\304\305D\"\210\306H\302!>\204$\303\304\305D\"\210\307H#\207" [cl-struct-cl--generic-tags cl--generic-make-next-function type-of signal wrong-type-argument cl--generic 2 3] 8 (#$ . 34090)])
#@35 

(fn GENERIC DISPATCHES METHODS)
(defalias 'cl--generic-make-next-function #[771 "
\203
@A@\211?\206\211\232\262
\203
A\262\202
\211A\262\242\211\203*
\2041\301\"\202;\302
!\211#\262
\207" [cl--generic-t-generalizer cl--generic-build-combined-method cl--generic-get-dispatcher] 9 (#$ . 34376)])
#@251 Table storing previously built combined-methods.
This is particularly useful when many different tags select the same set
of methods, since this table then allows us to share a single combined-method
for all those different tags in the method-cache.
(defvar cl--generic-combined-method-memoization (make-hash-table :test 'equal :weakness 'value) (#$ . 34698))
(define-error 'cl--generic-cyclic-definition "Cyclic definition: %S")
#@24 

(fn GENERIC METHODS)
(defalias 'cl--generic-build-combined-method #[514 "\211\204	\302\"\207

B\303\"\2066\304B\305#\210\3061(\307\"0\202-\210\302\"\304#\210\211\262
\266\202\211\305=\203X\310\311\312!	>\204P\310\313\314D\"\210\315HC\"\202Y\211\207" [cl--generic-combined-method-memoization cl-struct-cl--generic-tags cl--generic-standard-method-combination gethash puthash :cl--generic--under-construction (cl--generic-cyclic-definition) cl-generic-combine-methods signal cl--generic-cyclic-definition type-of wrong-type-argument cl--generic 1] 9 (#$ . 35134)])
#@23 

(fn GENERIC METHOD)
(defalias 'cl--generic-no-next-method-function #[514 "\300\301\302\303\304\"\305\"\306\307%\207" [make-byte-code 128 "\302\303\300\301$\207" vconcat vector [apply cl-no-next-method] 6 "\n\n(fn &rest ARGS)"] 9 (#$ . 35731)])
#@153 Return a function that calls METHOD.
FUN is the function that should be called when METHOD calls
`call-next-method'.

(fn GENERIC METHOD &optional FUN)
(defalias 'cl-generic-call-method #[770 "\301!>\204\302\303\304D\"\210
\305H\204(\301!>\204$\302\303\304D\"\210
\306H\207\301!>\2047\302\303\304D\"\210
\306H
\206B\307\"\310\311\312\313\314\"\315\"\316\317%\207" [cl-struct-cl--generic-method-tags type-of signal wrong-type-argument cl--generic-method 3 4 cl--generic-no-next-method-function make-byte-code 128 "\302\300\303\304\305\306\307\301\"\310\"\311\312%#\207" vconcat vector [apply make-byte-code 128 "\302\300\206\301\"\207" vconcat vector [apply] 4 "\n\n(fn &rest CNM-ARGS)"] 10 "\n\n(fn &rest ARGS)"] 12 (#$ . 35989)])
(defalias 'cl-method-qualifiers 'cl--generic-method-qualifiers)
#@24 

(fn GENERIC METHODS)
(defalias 'cl--generic-standard-method-combination #[514 "\302
\211\203n\211@\303
!>\204\304\305\306D\"\210\211\307H\211@\310=\203&\211AA\262
\211\311\235\204F\312\313\303!	>\204?\304\305\314\nD\"\210\315H#\210\211@\211\236
AB
\203Z

\241\210\202e
B\211\262B\262\266
A\266\202\202\210\211\204\203\316\317\320\321\322!\323\"\324\325%\202
\326\302\"\204\232\316\317\320\321\322!\327\"\324\325%\202
\302\316\330\331\321\322!\332\"\333\334%\335
\336\337\340\"A!\"\335\337\341\"A\"\337\302\"A\211\203\330\211@\342	#\262
A\266\202\202\302\210\211\204\341
\203\366\316\317\343\321\322#\344\"\345\325%\262\210\337\346\"A\211\203
\211@\342	#\262
A\266\202\202\374\210\266\204\207" [cl-struct-cl--generic-method-tags cl-struct-cl--generic-tags nil type-of signal wrong-type-argument cl--generic-method 2 :extra (nil (:after) (:before) (:around)) error "Unsupported qualifiers in function %S: %S" cl--generic 1 make-byte-code 128 "\301\302\300#\207" vconcat vector [apply cl-no-applicable-method] 5 "\n\n(fn &rest ARGS)" alist-get [apply cl-no-primary-method] 257 "\301\300\"\207" [cl-generic-call-method] 4 "\n\n(fn M)" mapcar reverse assoc :before :after cl-generic-call-method "\300\211\203\211@\303
\"\210
A\266\202\202
\210\303\302\"\301\211\203+\211@\303
\"\210
A\266\202\202\210\207" [apply] 7 :around] 16 (#$ . 36817)])
#@87 Like `apply' but takes a cl-generic object rather than a function.

(fn GENERIC ARGS)
(defalias 'cl-generic-apply #[514 "\301\302!>\204\303\304\305D\"\210\306H\"\207" [cl-struct-cl--generic-tags apply type-of signal wrong-type-argument cl--generic 1] 7 (#$ . 38245)])
#@28 

(fn METHOD DISPATCH-ARG)
(defalias 'cl--generic-arg-specializer #[514 "\211\250\203\211\301!>\204\302\303\304D\"\210\305H8\2023\306
\301!>\204.\302\303\304D\"\210\305H\"A\2067\307\207" [cl-struct-cl--generic-method-tags type-of signal wrong-type-argument cl--generic-method 1 assoc t] 8 (#$ . 38526)])
#@64 

(fn GENERIC DISPATCH-ARG DISPATCHES-LEFT METHODS-LEFT TYPES)
(defalias 'cl--generic-cache-miss #[1285 "\300\211\203%\211@\301
\"\211\235\211\203\211GBB\262\266
A\266\202\202\210\302\303\304\305\"\"\237\262
\306#\207" [nil cl--generic-arg-specializer mapcar cdr sort car-less-than-car cl--generic-make-next-function] 12 (#$ . 38852)])
(byte-code "\300\301\302\301\303\304#\305#\210\300\306\302\306\307\304#\310#\210\3111\301\312!0\202!\210\304\204,\301\313M\210\306\314M\210\315\301\304\316\304\317%\210\315\306\304\320\304\321%\207" [defalias cl-generic-generalizers cl-generic-define (specializer) nil "Return a list of generalizers for a given SPECIALIZER.\nTo each kind of `specializer', corresponds a `generalizer' which describes\nhow to extract a \"tag\" from an object which will then let us check if this\nobject matches the specializer.  A typical example of a \"tag\" would be the\ntype of an object.  It's called a `generalizer' because it\ntakes a specific object and returns a more general approximation,\ndenoting a set of objects to which it belongs.\nA generalizer gives us the chunk of code which the\ndispatch function needs to use to extract the \"tag\" of an object, as well\nas a function which turns this tag into an ordered list of\n`specializers' that this object matches.\nThe code which extracts the tag should be as fast as possible.\nThe tags should be chosen according to the following rules:\n- The tags should not be too specific: similar objects which match the\n  same list of specializers should ideally use the same (`eql') tag.\n  This insures that the cached computation of the applicable\n  methods for one object can be reused for other objects.\n- Corollary: objects which don't match any of the relevant specializers\n  should ideally all use the same tag (typically nil).\n  This insures that this cache does not grow unnecessarily large.\n- Two different generalizers G1 and G2 should not use the same tag\n  unless they use it for the same set of objects.  IOW, if G1.tag(X1) =\n  G2.tag(X2) then G1.tag(X1) = G2.tag(X1) = G1.tag(X2) = G2.tag(X2).\n- If G1.priority > G2.priority and G1.tag(X1) = G1.tag(X2) and this tag is\n  non-nil, then you have to make sure that the G2.tag(X1) = G2.tag(X2).\n  This is because the method-cache is only indexed with the first non-nil\n  tag (by order of decreasing priority).\n\n(fn SPECIALIZER)" cl-generic-combine-methods (generic methods) "Build the effective method made of METHODS.\nIt should return a function that expects the same arguments as the methods, and\n calls those methods in some appropriate order.\nGENERIC is the generic function (mostly used for its name).\nMETHODS is the list of the selected methods.\nThe METHODS list is sorted from most specific first to most generic last.\nThe function can use `cl-generic-call-method' to create functions that call those\nmethods.\n\n(fn GENERIC METHODS)" (error) t #[257 "\211\301=\205C\207" [cl--generic-t-generalizer t] 3 "\n\n(fn SPECIALIZER)"] cl--generic-standard-method-combination cl-generic-define-method (specializer) #[257 "\211\301=\203	C\207\302\303\"\207" [cl--generic-t-generalizer t error "Unknown specializer %S"] 4 "Support for the catch-all t specializer which always matches.\n\n(fn SPECIALIZER)"] (generic methods) #[514 "\300\"\207" [cl--generic-standard-method-combination] 5 "Standard support for :after, :before, :around, and `:extra NAME' qualifiers.\n\n(fn GENERIC METHODS)"]] 6)
(defconst cl--generic-nnm-sample (byte-code "\300\301\211\"\207" [cl--generic-no-next-method-function t] 3))
(defconst cl--generic-cnm-sample (byte-code "\300\301\302\303\301\211\304\305%C\" \207" [cl--generic-build-combined-method nil record cl--generic-method t identity] 8))
#@81 Return non-nil if CNM is the function that calls `cl-no-next-method'.

(fn CNM)
(defalias 'cl--generic-isnot-nnm-p #[257 "\3022\202\303
\"\204\304\305!\210\306
!\203G\211\307H\307H\211G\310\211W\203B\211\303H	\"\203:\311\302\303H	\"?\"\210\210\211T\262
\202\266\202~\242\312=\204R\304\313!\210\211A@A@\211\203|\211@\303
A	\"\203q\311\302\303@A	\"?\"\210A\262
A\266\202\202X\266\314\315!0\207" [cl--generic-cnm-sample cl--generic-nnm-sample found function-equal cl--assertion-failed (function-equal cnm cl--generic-cnm-sample) byte-code-function-p 2 0 throw closure (eq 'closure (car-safe cl--generic-cnm-sample)) error "Haven't found no-next-method-sample in cnm-sample"] 11 (#$ . 42618)])
(byte-code "\300\301\302\"\210\300\303\304\301#\210\300\305\306\301#\210\300\307\310\301#\210\311\303\312\303\313\314#\315#\210\316\303\314\313\314\317%\210\311\307\312\307\320\314#\321#\210\316\307\314\320\314\322%\210\311\305\312\305\323\314#\324#\210\316\305\314\323\314\325%\207" [define-error cl-no-method "No method" cl-no-next-method "No next method" cl-no-primary-method "No primary method" cl-no-applicable-method "No applicable method" defalias cl-generic-define (generic method &rest args) nil "Function called when `cl-call-next-method' finds no next method.\n\n(fn GENERIC METHOD &rest ARGS)" cl-generic-define-method #[642 "\301\302\303!>\204\301\304\305D\"\210\306HBB\"\207" [cl-struct-cl--generic-tags signal cl-no-next-method type-of wrong-type-argument cl--generic 1] 9 "\n\n(fn GENERIC METHOD &rest ARGS)"] (generic &rest args) "Function called when a method call finds no applicable method.\n\n(fn GENERIC &rest ARGS)" #[385 "\301\302\303!>\204\301\304\305D\"\210\306HB\"\207" [cl-struct-cl--generic-tags signal cl-no-applicable-method type-of wrong-type-argument cl--generic 1] 8 "\n\n(fn GENERIC &rest ARGS)"] (generic &rest args) "Function called when a method call finds no primary method.\n\n(fn GENERIC &rest ARGS)" #[385 "\301\302\303!>\204\301\304\305D\"\210\306HB\"\207" [cl-struct-cl--generic-tags signal cl-no-primary-method type-of wrong-type-argument cl--generic 1] 8 "\n\n(fn GENERIC &rest ARGS)"]] 6)
#@140 Function to call the next applicable method.
Can only be used from within the lexical body of a primary or around method.

(fn &rest ARGS)
(defalias 'cl-call-next-method #[128 "\300\301!\207" [error "cl-call-next-method only allowed inside primary and around methods"] 3 (#$ . 44804)])
#@120 Return non-nil if there is a next method.
Can only be used from within the lexical body of a primary or around method.
(defalias 'cl-next-method-p #[0 "\300\301!\207" [error "cl-next-method-p only allowed inside primary and around methods"] 2 (#$ . 45097)])
(make-obsolete 'cl-next-method-p "make sure there's always a next method, or catch `cl-no-next-method' instead" "25.1")
#@40 

(fn GENERIC QUALIFIERS SPECIALIZERS)
(defalias 'cl-find-method #[771 "\301
\302N\303
!>\204\304\305\302D\"\210\211\306H\262
#@\207" [cl-struct-cl--generic-tags cl--generic-member-method cl--generic type-of signal wrong-type-argument 3] 11 (#$ . 45481)])
#@138 For `find-function-regexp-alist'. Searches for a cl-defmethod.
MET-NAME is as returned by `cl--generic-load-hist-format'.

(fn MET-NAME)
(defalias 'cl--generic-search-method #[257 "\300\301\302\303@\"!\304Q\305
\306\307\310A@\311#\307\312\313\314	AA\"\315#R\316\314#\206,\305
\316\314#\207" ["(\\(?:cl-\\)?defmethod[ 	]+" regexp-quote format "%s" "\\_>" re-search-forward "[^&\"\n]*" mapconcat #[257 "\300\301\302\"!\207" [regexp-quote format "%S"] 5 "\n\n(fn QUALIFIER)"] "[ 	\n]*" #[257 "\300\301\302:\203A@\202\"!\207" [regexp-quote format "%S"] 5 "\n\n(fn SPECIALIZER)"] remq t "[ 	\n]*)[^&\"\n]*" nil] 11 (#$ . 45750)])
(defvar cl--generic-find-defgeneric-regexp "(\\(?:cl-\\)?defgeneric[ 	]+%s\\>")
(eval-after-load 'find-func #[0 "\301\302B\211\235\203\210\202\211B\210\303\211\235\203\202#\211B\211\207" [find-function-regexp-alist cl-defmethod cl--generic-search-method (cl-defgeneric . cl--generic-find-defgeneric-regexp)] 3])
#@15 

(fn METHOD)
(defalias 'cl--generic-method-info #[257 "\301
!>\204\302\303\304D\"\210\211\305H\301!>\204!\302\303\304D\"\210
\306H\301!>\2043\302\303\304D\"\210\307H\301!>\204F\302\303\304D\"\210\310H\311
\312\"\313!\204X\314\202l:\204a\315\316!\210\317!\211\305\320O\321P\262

\205\200\322\323\"\211\203}\211A\202~\262
\323\203\212A\262\211\203\304\211@@\324=\203\244\325\326\327G\"!\202\253\211A\262\242
\330=\203\265\211\202\270\211DB\262\210
A\266\202\202\214\210\331
\237\"\262

E\207" [cl-struct-cl--generic-method-tags type-of signal wrong-type-argument cl--generic-method 1 2 3 4 help-function-arglist names documentation "" cl--assertion-failed (consp qualifiers) prin1-to-string -1 " " help-split-fundoc nil &rest intern format "arg%d" t append] 16 (#$ . 46721)])
(add-hook 'help-fns-describe-function-functions 'cl--generic-describe)
#@17 

(fn FUNCTION)
(defalias 'cl--generic-describe #[257 "\2119\205\211\302N\211\205\236\303\304!\210\212\305c\210\306\307\310\311#c\210\312
!>\204*\313\314\302D\"\210\211\315H\211\205\233\211@\316
!\317\320@A@#c\210\321\312!	>\204R\313\314\322D\"\210\323H\312!	>\204e\313\314\322D\"\210\324H#\325
\326\"\211\203\205\327\330!c\210\331\332!\333\326%\210\327\334!c\210\266\335\3238\206\217\336\337\261\266
A\266\202\202-\262
)\207" [cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags cl--generic require help-mode "\n\nThis is a generic function.\n\n" propertize "Implementations:\n\n" face bold type-of signal wrong-type-argument 3 cl--generic-method-info format "%s%S" cl--generic-load-hist-format cl--generic-method 2 1 find-lisp-object-file-name cl-defmethod substitute-command-keys " in `" help-insert-xref-button help-fns-short-filename help-function-def "'.\n" "\n" "Undocumented" "\n\n"] 13 (#$ . 47630)])
#@87 Return non-nil if a method with SPECIALIZERS applies to TYPE.

(fn SPECIALIZERS TYPE)
(defalias 'cl--generic-specializers-apply-to-type-p #[514 "\300\211\203G\211@\211\242\301>\203\211A@\262
\211\302>\204@
\232\204=\2119\203@\211\303N\303N
\2058\211\2058\304!\235\266\202\203@\305\262
A\266\202\202\210\211\207" [nil (subclass eieio--static) (t eieio-default-superclass) cl--class cl--generic-class-parents t] 10 (#$ . 48585)])
#@145 Return a list of all generic functions.
Optional TYPE argument returns only those functions that contain
methods for TYPE.

(fn &optional TYPE)
(defalias 'cl-generic-all-functions #[256 "\300C\301\302\303\304\305\306\"\307\"\310\311%!\210\211\242\207" [nil mapatoms make-byte-code 257 "\304
!\205	\211\305N\211\205b\3062Y\300\204\307\306\310\"\210\311
!\n>\204)\312\313\305D\"\210\211\314H\211\205V\211@\315\311!>\204B\312\313\316D\"\210
\317H\300\"\203O\307\306\310\"\210
A\266\202\202,\262
0\205b\301\301\242B\240\207" vconcat vector [cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags fboundp cl--generic found throw t type-of signal wrong-type-argument 3 cl--generic-specializers-apply-to-type-p cl--generic-method 1] 9 "\n\n(fn SYMBOL)"] 10 (#$ . 49037)])
#@168 Return info for all methods of FUNCTION (a symbol) applicable to TYPE.
The value returned is a list of elements of the form
(QUALIFIERS ARGS DOC).

(fn FUNCTION TYPE)
(defalias 'cl--generic-method-documentation #[514 "
\302N\303
\203H\304!>\204\305\306\302D\"\210
\307H\211\203G\211@\310\304!	>\2040\305\306\311D\"\210
\312H\"\203@\313
!B\262
A\266\202\202\210\207" [cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags cl--generic nil type-of signal wrong-type-argument 3 cl--generic-specializers-apply-to-type-p cl--generic-method 1 cl--generic-method-info] 11 (#$ . 49835)])
#@306 Return a list of files where METHOD is defined by `cl-defmethod'.
The list will have entries of the form (FILE . (METHOD ...))
where (METHOD ...) contains the qualifiers and specializers of
the method and is a suitable argument for
`find-function-search-for-symbol'.  Filenames are absolute.

(fn METHOD)
(defalias 'cl--generic-method-files #[257 "\301\211\203>\211@\211@
A\211
\211\2035\211@\211\242\302=\203.\211A@\n=\203.
AB	B\262	
A\266\202\202\266
A\266\202\202\210\211\207" [load-history nil cl-defmethod] 12 (#$ . 50445)])
(defvar cl--generic-head-used (make-hash-table :test 'eql))
(defconst cl--generic-head-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\301D\302BB\207" [gethash car-safe (cl--generic-head-used)] 5 "\n\n(fn NAME &rest _)"] #[385 "
\242\300=\205	
C\207" [head] 4 "\n\n(fn TAG &rest _)"] record cl--generic-generalizer cl--generic-head-generalizer 80] 8))
(byte-code "\302\303\304\305\306\307%\210\310\311\303\312!C\"B\313
\314	#\210\207" [cl--generic-t-generalizer cl--generic-dispatchers cl-generic-define-method cl-generic-generalizers (:extra "head") (specializer) t #[514 "\211\242\302=\204\n
 \207\211A@\303\"\204\304#\266\266	C\207" [cl--generic-head-used cl--generic-head-generalizer head gethash puthash] 9 "Support for (head VAL) specializers.\nThese match if the argument is a cons cell whose car is `eql' to VAL.\n\n(fn CL--CNM SPECIALIZER)"] 0 append (head eql) puthash #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 385 "\305\306\242\f\"\303\306\"\206*\307\300\310\301\302\311\312\306\f\242\f\"!\313\314!\"%\315#\210\211\262
\266\202#\207" vconcat vector [cl--generic-head-used apply gethash cl--generic-cache-miss 0 append (closure (cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags . #1=(cl-struct-cl--generic-generalizer-tags t)) (tag &rest _) (if (eq (car-safe tag) 'head) (list tag))) (closure #1# (_tag &rest _) '(t)) nil puthash] 15 "\n\n(fn ARG &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"]] 6)
(defvar cl--generic-eql-used (make-hash-table :test 'eql))
(defconst cl--generic-eql-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\301BB\207" [gethash (cl--generic-eql-used)] 5 "\n\n(fn NAME &rest _)"] #[385 "
\242\300=\205	
C\207" [eql] 4 "\n\n(fn TAG &rest _)"] record cl--generic-generalizer cl--generic-eql-generalizer 100] 8))
(byte-code "\302\303\304\305\304\306%\210\307\310\303\311!C\"B\312
\313	#\266\314\310\303\315!C\"B\312
\316	#\266\317\310\303\320!C\"B\312
\321	#\266\322\310\303\323!C\"B\312
\324	#\210\207" [cl--generic-t-generalizer cl--generic-dispatchers cl-generic-define-method cl-generic-generalizers nil ((specializer (head eql))) #[257 "\302
A@#\210	C\207" [cl--generic-eql-used cl--generic-eql-generalizer puthash] 5 "Support for (eql VAL) specializers.\nThese match if the argument is `eql' to VAL.\n\n(fn SPECIALIZER)"] 0 append (eql nil) puthash #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 385 "\305\306\f\"\303\306\"\206(\307\300\310\301\302\311\312\306\f\f\"!\313\314!\"%\315#\210\211\262
\266\202#\207" vconcat vector [cl--generic-eql-used apply gethash cl--generic-cache-miss 0 append #2=(closure (cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags . #1=(cl-struct-cl--generic-generalizer-tags t)) (tag &rest _) (if (eq (car-safe tag) 'eql) (list tag))) #3=(closure #1# (_tag &rest _) '(t)) nil puthash] 15 "\n\n(fn ARG &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"] (&context . window-system) (eql nil) #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 128 "\f\306\307
\"\303\307\"\206)\310\300\311\301\302\312\313\307
\"!\314\315!\"%\316#\210\211\262
\266\202\"\207" vconcat vector [window-system cl--generic-eql-used apply gethash cl--generic-cache-miss (&context . window-system) append #2# #3# nil puthash] 15 "\n\n(fn &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"] (&context terminal-parameter nil 'xterm--get-selection) (eql nil) #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 128 "\305\306\307\"\310\311\f\"\303\311\"\206,\312\300\313\301\302\314\315\311\f\"!\316\306!\"%\317#\210\211\262
\266\202\"\207" vconcat vector [cl--generic-eql-used terminal-parameter nil xterm--get-selection apply gethash cl--generic-cache-miss (&context terminal-parameter nil 'xterm--get-selection) append #2# #3# puthash] 15 "\n\n(fn &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"] (&context terminal-parameter nil 'xterm--set-selection) (eql nil) #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 128 "\305\306\307\"\310\311\f\"\303\311\"\206,\312\300\313\301\302\314\315\311\f\"!\316\306!\"%\317#\210\211\262
\266\202\"\207" vconcat vector [cl--generic-eql-used terminal-parameter nil xterm--set-selection apply gethash cl--generic-cache-miss (&context terminal-parameter nil 'xterm--set-selection) append #2# #3# puthash] 15 "\n\n(fn &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"]] 6)
#@21 

(fn NAME &rest _)
(defalias 'cl--generic-struct-tag #[385 "\300\301D\302BBB\207" [if type-of ('null)] 6 (#$ . 55757)])
#@14 

(fn CLASS)
(defalias 'cl--generic-class-parents #[257 "\301
C\211
A\262\242\302
!>\204\303\304\305D\"\210\211\306H\307
\"\204'\211B\262\210\310\302!>\2049\303\304\305D\"\210\311H\"\211\262\262
\204
\237\207" [cl-struct-cl--class-tags nil type-of signal wrong-type-argument cl--class 1 memql append 3] 10 (#$ . 55886)])
#@20 

(fn TAG &rest _)
(defalias 'cl--generic-struct-specializers #[385 "
9\205
\301N\302
!>\205\303
!\262
\207" [cl-struct-cl-structure-class-tags cl--class type-of cl--generic-class-parents] 5 (#$ . 56231)])
(defconst cl--generic-struct-generalizer (record 'cl--generic-generalizer 'cl--generic-struct-generalizer 50 'cl--generic-struct-tag 'cl--generic-struct-specializers))
(byte-code "\302\303\304\305\306\307%\210\310\311\303\312!C\"B\313
\314	#\210\207" [cl--generic-t-generalizer cl--generic-dispatchers cl-generic-define-method cl-generic-generalizers (:extra "cl-struct") (type) t #[514 "\2119\203_\211\302N\303
!>\205Z\303
!>\204\304\305\306D\"\210\211\307H\203?\310\311\303!>\2048\304\305\306D\"\210\307H#\205Z\303
!>\204N\304\305\306D\"\210\211\312H\203X\313\314!\210	C\262
\206a
 \207" [cl-struct-cl-structure-class-tags cl--generic-struct-generalizer cl--class type-of signal wrong-type-argument cl-structure-class 7 error "Can't dispatch on cl-struct %S: type is %S" 8 cl--assertion-failed (null (cl--struct-class-named class))] 10 "Support for dispatch on types defined by `cl-defstruct'.\n\n(fn CL--CNM TYPE)"] 0 append cl--generic-generalizer puthash #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 385 "\304\203\305!\202\f\306\303\307\"\2067\310\300\311\301\302\312\313\203'\305\f!\202(\306!\314\315!\"%\316#\210\211\262
\266\202#\207" vconcat vector [apply type-of null gethash cl--generic-cache-miss 0 append cl--generic-struct-specializers (closure (cl-struct-cl--generic-generalizer-tags t) (_tag &rest _) '(t)) nil puthash] 14 "\n\n(fn ARG &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"]] 6)
#@211 Alist of supertypes.
Each element has the form (TYPE . SUPERTYPES) where TYPE is one of
the symbols returned by `type-of', and SUPERTYPES is the list of its
supertypes from the most specific to least specific.
(defconst cl--generic-typeof-types '((integer number number-or-marker atom) (symbol atom) (string array sequence atom) (cons list sequence) (marker number-or-marker atom) (overlay atom) (float number atom) (window-configuration atom) (process atom) (window atom) (subr atom) (compiled-function function atom) (buffer atom) (char-table array sequence atom) (bool-vector array sequence atom) (frame atom) (hash-table atom) (terminal atom) (thread atom) (mutex atom) (condvar atom) (font-spec atom) (font-entity atom) (font-object atom) (vector array sequence atom) (null symbol list sequence atom)) (#$ . 57974))
(defconst cl--generic-all-builtin-types (byte-code "\301\302\303\304\"!!\207" [cl--generic-typeof-types delete-dups copy-sequence apply append] 5))
(defconst cl--generic-typeof-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[385 "\300\301D\302BBB\207" [if type-of ('null)] 6 "\n\n(fn NAME &rest _)"] #[385 "
9\205
\236\207" [cl--generic-typeof-types] 4 "\n\n(fn TAG &rest _)"] record cl--generic-generalizer cl--generic-typeof-generalizer 10] 8))
(byte-code "\302\303\304\305\306\307%\210\310\311\303\312!C\"B\313
\314	#\210\207" [cl--generic-t-generalizer cl--generic-dispatchers cl-generic-define-method cl-generic-generalizers (:extra "typeof") (type) t #[514 "\211>\203	C\206

 \207" [cl--generic-all-builtin-types cl--generic-typeof-generalizer] 4 "Support for dispatch on builtin types.\nSee the full list and their hierarchy in `cl--generic-typeof-types'.\n\n(fn CL--CNM TYPE)"] 0 append integer puthash #[771 "\300\301\302\"\303\304\305\306\307$\310\"\311\312%\207" [make-hash-table :test eql make-byte-code 385 "\304\203\305!\202\f\306\303\307\"\2067\310\300\311\301\302\312\313\203'\305\f!\202(\306!\314\315!\"%\316#\210\211\262
\266\202#\207" vconcat vector [apply type-of null gethash cl--generic-cache-miss 0 append (closure (cl-struct-cl--generic-tags cl-struct-cl--generic-method-tags . #1=(cl-struct-cl--generic-generalizer-tags t)) (tag &rest _) (and (symbolp tag) (assq tag cl--generic-typeof-types))) (closure #1# (_tag &rest _) '(t)) nil puthash] 14 "\n\n(fn ARG &rest ARGS)"] 13 "\n\n(fn GENERIC DISPATCHES-LEFT METHODS)"]] 6)
#@21 

(fn MODE &rest _)
(defalias 'cl--generic-derived-specializers #[385 "\300\203\301D
B\262
\302N\262\202
\211\237\207" [nil derived-mode derived-mode-parent] 5 (#$ . 60398)])
(defconst cl--generic-derived-generalizer (byte-code "\300\301\302\303\304\305%\207" [#[257 "\300\301D\302DF\207" [and symbolp functionp] 5 "\n\n(fn NAME)"] record cl--generic-generalizer cl--generic-derived-generalizer 90 cl--generic-derived-specializers] 7))
(byte-code "\300\301\302\303\302\304%\210\305\306\307\310#\210\300\311\302\312\302\313%\210\314\315!\207" [cl-generic-define-method cl-generic-generalizers nil ((_specializer (head derived-mode))) #[257 "C\207" [cl--generic-derived-generalizer] 2 "Support for (derived-mode MODE) specializers.\nUsed internally for the (major-mode MODE) context specializers.\n\n(fn SPECIALIZER)"] put major-mode cl-generic--context-rewriter #[385 "\300:\203
\203\301\302!\210\202\303BBD\207" [major-mode cl--assertion-failed (null modes) derived-mode] 6 "\n\n(fn MODE &rest MODES)"] loadhist-unload-element ((x (head cl-defmethod))) #[257 "\211A\211@
A\211@
A\211\301
\302\"\211\205M\303
!>\204$\304\305\306D\"\210\211\307H\310#\211\205K\303!>\204?\304\305\306D\"\210\211\307\311@\"I\262
\266\202\262
\266\203\207" [cl-struct-cl--generic-tags cl-generic-ensure-function noerror type-of signal wrong-type-argument cl--generic 3 cl--generic-member-method delq] 18 "\n\n(fn X)"] provide cl-generic] 6)