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



(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require cl-lib macroexp gv] 2)
#@14 

(fn PLACE)
(defalias 'cl--pop2 '(macro . #[257 "\300\301\302DD\303\302\211DDEE\207" [prog1 car cdr setq] 8 (#$ . 169)]))
(put 'cl--pop2 'edebug-form-spec 'edebug-sexps)
#@30 

(fn FORM ARG &rest OTHERS)
(defalias 'cl--compiler-macro-list* #[642 "\300B!\211@
A\211\262\203\301@E\262
\202\207" [reverse cons] 8 (#$ . 350)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias cl--compiler-macro-cXXr internal--compiler-macro-cXXr nil make-obsolete "25.1"] 4)
(defconst cl--simple-funcs '(car cdr nth aref elt if and or + - 1+ 1- min max car-safe cdr-safe progn prog1 prog2))
(defconst cl--safe-funcs '(* / % length memq list vector vectorp < > <= >= = error))
#@72 Check if no side effects, and executes quickly.

(fn X &optional SIZE)
(defalias 'cl--simple-expr-p #[513 "\211\204\301\262

:\203K
@\302>\204K
@9\205S
@>\204'
@\303N\205S\211S\262

A\211\262\203>\304@\"\211\262\204+
?\205J\211\305Y\205J\211\207\211\305V\205S\211S\207" [cl--simple-funcs 10 (quote function cl-function) side-effect-free cl--simple-expr-p 0] 5 (#$ . 863)])
#@11 

(fn XS)
(defalias 'cl--simple-exprs-p #[257 "\211\203\300
@!\203\211A\262
\202\211?\207" [cl--simple-expr-p] 3 (#$ . 1259)])
#@35 Check if no side effects.

(fn X)
(defalias 'cl--safe-expr-p #[257 "\211:\205\n\211@\302>??\206:\211@9\205:\211@>\204)\211@	>\204)\211@\303N\205:\211A\211\262\2038\304
@!\204)\211?\207" [cl--simple-funcs cl--safe-funcs (quote function cl-function) side-effect-free cl--safe-expr-p] 3 (#$ . 1398)])
#@10 

(fn X)
(defalias 'cl--const-expr-p #[257 "\211:\203%\211@\300=\2063\211@\301>\205$\211A@9\206$\211A@\242\302=\205$\303\207\2119\2032\211\304>\2053\305\207\305\207" [quote #'cl-function lambda func (nil t) t] 3 (#$ . 1712)])
#@213 Return the value of X known at compile-time.
If X is not known at compile time, return nil.  Before testing
whether X is known at compile time, macroexpand it completely in
`macroexpand-all-environment'.

(fn X)
(defalias 'cl--const-expr-val #[257 "\301
\"\302
!\205\211:\203\211A@\207\211\207" [macroexpand-all-environment macroexpand-all macroexp-const-p] 4 (#$ . 1952)])
#@73 Count number of times X refers to Y.  Return nil for 0 times.

(fn X Y)
(defalias 'cl--expr-contains #[514 "\211\232\203\300\207
:\203B
@\301>\204B\302:\203.\211\303\211A\262\242\"\206(\302\\\262
\202\211\303\"\2067\302\\\262
\211\302V\205A\211\207\304\207" [1 (quote function cl-function) 0 cl--expr-contains nil] 7 (#$ . 2337)])
#@12 

(fn X Y)
(defalias 'cl--expr-contains-any #[514 "\211\203\300@\"\204\211A\262
\202\207" [cl--expr-contains] 5 (#$ . 2691)])
#@66 Check whether X may depend on any of the symbols in Y.

(fn X Y)
(defalias 'cl--expr-depends-p #[514 "\300!?\205\301!?\206\302\"\207" [macroexp-const-p cl--safe-expr-p cl--expr-contains-any] 5 (#$ . 2831)])
(defvar cl--gensym-counter 0)
#@121 Generate a new uninterned symbol.
The name is made by appending a number to PREFIX, default "G".

(fn &optional PREFIX)
(defalias 'cl-gensym #[256 "\211;\203	\211\202\n\301
\250\203
\202\211T\302\303\304#!\207" [cl--gensym-counter "G" make-symbol format "%s%d"] 8 (#$ . 3083)])
(defvar cl--gentemp-counter 0)
#@138 Generate a new interned symbol with a unique name.
The name is made by appending a number to PREFIX, default "T".

(fn &optional PREFIX)
(defalias 'cl-gentemp #[256 "\211;\203	\211\202\n\301\302\303\304\305#\211\262!\203T\202\306
!\207" [cl--gentemp-counter "T" nil intern-soft format "%s%d" intern] 8 (#$ . 3409)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\210\300\313\314\"\210\300\315\316\"\210\300\317\320\"\207" [def-edebug-elem-spec cl-declarations (&rest ("cl-declare" &rest sexp)) cl-declarations-or-string (lambda-doc &or ("declare" def-declarations) cl-declarations) cl-lambda-list (([&rest cl-lambda-arg] [&optional ["&optional" cl-&optional-arg &rest cl-&optional-arg]] [&optional ["&rest" cl-lambda-arg]] [&optional ["&key" [cl-&key-arg &rest cl-&key-arg] &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (cl-lambda-arg &optional def-form) arg]] . [&or arg nil])) cl-&optional-arg (&or (cl-lambda-arg &optional def-form arg) arg) cl-&key-arg (&or ([&or (symbolp cl-lambda-arg) arg] &optional def-form arg) arg) cl-lambda-arg (&or arg cl-lambda-list1) cl-lambda-list1 (([&optional ["&whole" arg]] [&rest cl-lambda-arg] [&optional ["&optional" cl-&optional-arg &rest cl-&optional-arg]] [&optional ["&rest" cl-lambda-arg]] [&optional ["&key" cl-&key-arg &rest cl-&key-arg &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (cl-lambda-arg &optional def-form) arg]] . [&or arg nil])) cl-type-spec (sexp)] 3)
(defconst cl--lambda-list-keywords '(&optional &rest &key &allow-other-keys &aux &whole &body &environment))
#@270 Transform a function form FORM of name BIND-BLOCK.
BIND-BLOCK is the name of the symbol to which the function will be bound,
and which will be used for the name of the `cl-block' surrounding the
function's body.
FORM is of the form (ARGS . BODY).

(fn FORM BIND-BLOCK)
(defalias 'cl--transform-lambda #[514 "
@A
\306\211\307!\211@\306A\262<\203!\310!\202%\311D\262\312!\211A\2037\211\311AD\241\210\210\313>\211\203Q\211A@\211
AA\241\210\314\313\"\262\210\315>\211\203b\314\315\"\262\316>\203m\317\320!\210\321>\211A@
\203\211\314@\314\"\"\322\323BD\244\262\266\306\203\321@9\203\321@\324>\204\321\211\203\257@	A\236A@\204\321@\325=\203\303\326\211\262\203\303	@\204\321\211A\262\242B\262\202\214\211\203\353\203\340\325B\262
@\325=\203\353
A\262\210\327=\204\373\330BBC\262\306\211\204
\306\202j
@\322=\203
\331!\210\237\306\202j
\211G\325>\203&
\211S\262
\332 \333\334\"\216\335@;\205:
\211A\262\242\336\306\326\211()\337\340\341\342\f!B\"+!\")B\262
\262\343\344#\210\237\311\211A\242@D\262
\345\237\"\345\346\347\345\f\237
\"!\"C\"*B\262
+\207" [cl--bind-block cl--bind-defs cl--bind-enquote cl--bind-lets cl--bind-forms print-escape-newlines nil macroexp-parse-body cl-copy-list &rest last &cl-defs delq &cl-quote &whole error "&whole not currently implemented" &environment &aux (macroexpand-all-environment) (nil &rest &body &key &aux) &optional t cl-none cl-block cl--do-&aux match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] help-add-fundoc-usage help--docstring-quote format "%S" fn cl--make-usage-args cl--do-arglist :dummy append macroexp-let* macroexp-progn print-quoted print-gensym] 19 (#$ . 5031)])
#@703 Define NAME as a function.
Like normal `defun', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (cl-block NAME ...).

The full form of a Common Lisp function argument list is

   (VAR...
    [&optional (VAR [INITFORM [SVAR]])...]
    [&rest|&body VAR]
    [&key (([KEYWORD] VAR) [INITFORM [SVAR]])... [&allow-other-keys]]
    [&aux (VAR [INITFORM])...])

VAR may be replaced recursively with an argument list for
destructuring, `&whole' is supported within these sublists.  If
SVAR, INITFORM, and KEYWORD are all omitted, then `(VAR)' may be
written simply `VAR'.  See the Info node `(cl)Argument Lists' for
more details.

(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defun '(macro . #[642 "\300\301B\"BB\207" [defun cl--transform-lambda] 8 (#$ . 6803)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\300\207" [put cl-defun edebug-form-spec (&define [&name sexp] cl-lambda-list cl-declarations-or-string [&optional ("interactive" interactive)] def-body) function-put doc-string-elt 3 lisp-indent-function 2] 5)
#@213 Define NAME as a generator function.
Like normal `iter-defun', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (cl-block NAME ...).

(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-iter-defun '(macro . #[642 "\300\301!\210\302\303B\"BB\207" [require generator iter-defun cl--transform-lambda] 8 (#$ . 7897)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\311\312\313\"\210\311\314\315\"\210\311\316\317\"\207" [put cl-iter-defun edebug-form-spec (&define [&name sexp] cl-lambda-list cl-declarations-or-string [&optional ("interactive" interactive)] def-body) function-put doc-string-elt 3 lisp-indent-function 2 def-edebug-elem-spec cl-macro-list (([&optional "&environment" arg] [&rest cl-macro-arg] [&optional ["&optional" &rest &or (cl-macro-arg &optional def-form cl-macro-arg) arg]] [&optional [[&or "&rest" "&body"] cl-macro-arg]] [&optional ["&key" [&rest [&or ([&or (symbolp cl-macro-arg) arg] &optional def-form cl-macro-arg) arg]] &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (cl-macro-arg &optional def-form) arg]] [&optional "&environment" arg])) cl-macro-arg (&or arg cl-macro-list1) cl-macro-list1 (([&optional "&whole" arg] [&rest cl-macro-arg] [&optional ["&optional" &rest &or (cl-macro-arg &optional def-form cl-macro-arg) arg]] [&optional [[&or "&rest" "&body"] cl-macro-arg]] [&optional ["&key" [&rest [&or ([&or (symbolp cl-macro-arg) arg] &optional def-form cl-macro-arg) arg]] &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (cl-macro-arg &optional def-form) arg]] . [&or arg nil]))] 5)
#@723 Define NAME as a macro.
Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (cl-block NAME ...).

The full form of a Common Lisp macro argument list is

   (VAR...
    [&optional (VAR [INITFORM [SVAR]])...]
    [&rest|&body VAR]
    [&key (([KEYWORD] VAR) [INITFORM [SVAR]])... [&allow-other-keys]]
    [&aux (VAR [INITFORM])...]
    [&environment VAR])

VAR may be replaced recursively with an argument list for
destructuring, `&whole' is supported within these sublists.  If
SVAR, INITFORM, and KEYWORD are all omitted, then `(VAR)' may be
written simply `VAR'.  See the Info node `(cl)Argument Lists' for
more details.

(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defmacro '(macro . #[642 "\300\301B\"BB\207" [defmacro cl--transform-lambda] 8 (#$ . 9516)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\311\312\313\"\210\311\314\315\"\207" [put cl-defmacro edebug-form-spec (&define name cl-macro-list cl-declarations-or-string def-body) function-put doc-string-elt 3 lisp-indent-function 2 def-edebug-elem-spec cl-lambda-expr (&define ("lambda" cl-lambda-list cl-declarations-or-string [&optional ("interactive" interactive)] def-body)) function-form (&or ([&or "quote" "function"] &or symbolp lambda-expr) ("cl-function" cl-function) form)] 5)
#@155 Introduce a function.
Like normal `function', except that if argument is a lambda form,
its argument list allows full Common Lisp conventions.

(fn FUNC)
(defalias 'cl-function '(macro . #[257 "\211\242\300=\203\301\300\302A\303\"BD\207\301
D\207" [lambda function cl--transform-lambda cl-none] 6 (#$ . 10869)]))
(put 'cl-function 'edebug-form-spec '(&or symbolp cl-lambda-expr))
#@58 X can be a var or a (destructuring) lambda-list.

(fn X)
(defalias 'cl--make-usage-var #[257 "\2119\203\f\300\301!\226!\207\211:\203\302
!\207\207" [make-symbol symbol-name cl--make-usage-args] 4 (#$ . 11258)])
#@16 

(fn ARGLIST)
(defalias 'cl--make-usage-args #[257 "\3001\f\301\302\"0\202\210\303\211\203\304\305#\262\210\306
!\2048\307
!\211A\310\311#\216
\303\241\210\312!\313!\244)\207\314
>\211\203K\315
@\316A@\"\"\262\210\303C\317\310\320\"\"\207" [(error) cl-position &aux nil cl-subseq 0 proper-list-p last make-closure #[0 "\300\301\241\207" [V0 V1] 2] cl--make-usage-args cl--make-usage-var &cl-defs delq remq mapcar #[257 "\2119\203*\301
!\302H\211\303=\203\300\240\207\304
\305=\203$\301!\306\307O\202'\301!\226!\207\211:\2040\207\300\242\310>\203;\311
!\207\211@:\203U\300\242\312=\203U\211@@\313@A@!D\202Y\313
@!
A@\311AA!BB\207" [V0 symbol-name 0 38 make-symbol 95 1 nil (nil &rest) cl--make-usage-args &key cl--make-usage-var] 6 "\n\n(fn X)"]] 7 (#$ . 11479)])
#@13 

(fn ARGS)
(defalias 'cl--do-&aux #[257 "\211@\302=\203]\211
A\262\242\203]\211\203\211@>\204\211@:\203P	\203?\211@A@\203?\303
@@\304\211A\262\242A@D\"\210\202\303
@@\211A\262\242A@\"\210\202\303
\211A\262\242\305\"\210\202\211\205e\306\307\"\207" [cl--lambda-list-keywords cl--bind-enquote &aux cl--do-arglist quote nil error "Malformed argument list ends with: %S"] 6 (#$ . 12284)])
#@32 

(fn ARGS EXPR &optional NUM)
(defalias 'cl--do-arglist #[770 "<\204>\2049\204\306\307\"\207D	B\211\207\310!\262\311!\211A\2031\211\312AD\241\210\210\313>\211\203=\211\312\240\210\210\314>\203H\306\315!\210\312>\316 \203T\n\202U\317\320\321\211\211\204a\322\262A@<\203n\323\324!\202qA@\262D	B@\325=\203\222A@	AA\262\nD	B\262\211\203\266\211@>\204\266\211\n=\204\257\326D\262\211A\262
\202\230\211@\327>\203\322\330\331D\332\f\"GE\262	
=?\262\210\203.
@>\204.
A\204\352
\204\356\333\202\357\334D\335\n\211A\262\f\242\204
\322U\203	
\202 
\336\337\340\341\342=?\205
\343D\331DEEF\"\266T\262\320\262\202\323@\344=\203\264
\211A\262\n\242\203\264
\203.
@>\204.
\211A\262\n\242\211:\204]
\211C\262
\211AA\203o
\335\3458\346	\347BB\"\210\211A\203z
\211A@\202\205
\f@\206\205
\211@\f\236A@\333D
\203\226

\203\226
\343D\262\335@\203\247
\336F\202\250
\"\210	T\262\n\266\202@
@\312=\203\325
A@	AA\262\n\211:\203\321
\335
\"\210\210\202@\350=\204\322U\204
\204\336\337\351\341\342=?\205\367
\343D\352
\331DEEEE@B@@\350=\203\211A\262\n\242\203<\204!\321\262\203@>\204\211A\262\n\242\211:\204>\211C\262
\211@:\203J\211@@\202d\353
@!\211\322H\354=\203\\\211\355\321O\262
\356\357\360\"!\262

@:\203q
@A@\202s
@A\203~A@\202\210\f@\206\210\211\f\236A@\361\n\343DE
\203\234
\203\234\343D\262AA\203\313\3458\206\253\323\362!\363\326DD\335\"\210\335\336\364\365\366BBEF\"\266\202\367\335\363\326\204\327\202\363\367\370!\320=\203\355\343\321\371\n!DD\202\362\341\321	EEDD\"\210	B\262	\266\202!:\203\237\262@\372=\203\211A\262\n\242\204\241\322U\204\241\320=\204\241\204D\373\306\357\374\"\363\nDEE@B@\202\241\323\375!\376\377\201A\201B\363D\343\201C\f\"DE\365\326\211	DDED\363\326\201B\343BEDD\365\201DBBD\320\306\357\374\"\363\nDEDFE\201E\nDCE@B@\266\201F	!\266\321\207" [cl--lambda-list-keywords cl--bind-lets cl--optimize-safety cl--bind-block cl--bind-defs cl--bind-enquote error "Invalid argument name: %s" cl-copy-list last &rest &body &environment "&environment used incorrectly" macroexp-compiling-p 3 t nil 0 make-symbol "--cl-rest--" &whole cdr (nil &aux) = length cl-ldiff pop car-safe cl--do-arglist if signal 'wrong-number-of-arguments list cl-none quote &optional 2 and (t) &key 'wrong-number-of-arguments + symbol-name 95 1 intern format ":%s" plist-member "--cl-var--" car prog1 setq (t) or cl--const-expr-p cl--const-expr-val &allow-other-keys when "Keyword argument %%s not one of %s" "--cl-keys--" (:allow-other-keys) while cl--bind-forms cond memq append (nil) let cl--do-&aux] 25 (#$ . 12700)])
#@13 

(fn ARGS)
(defalias 'cl--arglist-args #[257 "\211<\204\211C\207\301\211\211:\203]\211A\262\242\262
\211>\203$\211\262\202\211\302=\2031A\262\202\211:\203>
\203>\211@\262
\211:\203S\211A\203S
\303=\203S\211A@\262
\304!\244\262\202\205dC\244\207" [cl--lambda-list-keywords nil &cl-defs &key cl--arglist-args] 7 (#$ . 15491)])
#@95 Bind the variables in ARGS to the result of EXPR and execute BODY.

(fn ARGS EXPR &rest BODY)
(defalias 'cl-destructuring-bind '(macro . #[642 "\305\211\305\305\306\206\307\"\210\310\237\311\312	\237\"!\"-\207" [cl--bind-lets cl--bind-forms cl--bind-defs cl--bind-block cl--bind-enquote nil cl--do-arglist (&aux) macroexp-let* macroexp-progn append] 10 (#$ . 15853)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-destructuring-bind lisp-indent-function 2 put edebug-form-spec (&define cl-macro-list1 def-form cl-declarations def-body)] 5)
(defvar cl--not-toplevel nil)
#@283 Control when BODY is evaluated.
If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.

(fn (WHEN...) BODY...)
(defalias 'cl-eval-when '(macro . #[385 "\302 \203K\204K\303\304!\204K\305>\206\306>\307\310>\204&\311>\203=\211\2033\312\313\314\"B\202I\315\316\211BBB\202I\211\203H\317\312B	\"\210\316)\207\317>\204W\320>\205Z\312
B\207" [cl--not-toplevel lexical-binding macroexp-compiling-p boundp for-effect compile :compile-toplevel t load :load-toplevel progn mapcar cl--compile-time-too if nil eval :execute] 7 (#$ . 16466)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-eval-when lisp-indent-function 1 put edebug-form-spec (sexp body)] 5)
#@13 

(fn FORM)
(defalias 'cl--compile-time-too #[257 "\211\2429\203
\211\242\302N\204\303
\304B\"\262
\211\242\305=\203$\305\306\307A\"B\207\211\242\310=\203F\211A@\311
>\204:\312
>\203D\310\313BAABB\207
\207\311
	\"\210\207" [macroexpand-all-environment lexical-binding byte-hunk-handler macroexpand (cl-eval-when) progn mapcar cl--compile-time-too cl-eval-when eval :execute compile] 5 (#$ . 17335)])
#@152 Like `progn', but evaluates the body at load time.
The result of the body appears to the compiler as a quoted constant.

(fn FORM &optional READ-ONLY)
(defalias 'cl-load-time-value '(macro . #[513 "\302 \2034\303\304!\305
E\306\307!\203-\310\311!\203-\310\312!\203-\313\211K\314\315#\262
M\210\2022\316
\"\210
\207\317\320	\"D\207" [byte-compile--outbuffer lexical-binding macroexp-compiling-p cl-gentemp "--cl-load-time--" setq fboundp byte-compile-file-form-defmumble boundp this-kind that-one byte-compile-file-form make-closure #[257 "\302\301M\210\302\300!\210\302
!\207" [V0 V1 byte-compile-file-form] 3 "\n\n(fn FORM)"] print quote eval] 10 (#$ . 17753)]))
(put 'cl-load-time-value 'edebug-form-spec '(form &optional sexp))
#@485 Eval EXPR and choose among clauses on that value.
Each clause looks like (KEYLIST BODY...).  EXPR is evaluated and
compared against each key in each KEYLIST; the corresponding BODY
is evaluated.  If no clause succeeds, this macro returns nil.  A
single non-nil atom may be used in place of a KEYLIST of one
atom.  A KEYLIST of t or `otherwise' is allowed only in the final
clause, and matches if no other keys match.  Key values are
compared by `eql'.

(fn EXPR (KEYLIST BODY...)...)
(defalias 'cl-case '(macro . #[385 "\300!\203\n
\202
\301\302!\303C\304\305\306\307#\"B\262

=\203\"\207\310DC\"\207" [macroexp-copyable-p make-symbol "temp" nil cond mapcar make-closure #[257 "\211@\302>\203\303\202U\211@\304=\203\305\306\300\307\310\301\242!DF\202U\211@<\2038\301\311@\301\242\"\240\210\312\300\307@DE\202U\211@\301\242>\203F\305\313@\"\210\301
@\301\242B\240\210\314\300\307@DE
A\206[\315B\207" [V0 V1 (t otherwise) t cl--ecase-error-flag error "cl-ecase failed: %s, %s" quote reverse append cl-member "Duplicate key in case: %s" eql (nil)] 7 "\n\n(fn C)"] macroexp-let*] 10 (#$ . 18501)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-case lisp-indent-function 1 put edebug-form-spec (form &rest (sexp body))] 5)
#@113 Like `cl-case', but error if no case fits.
`otherwise'-clauses are not allowed.

(fn EXPR (KEYLIST BODY...)...)
(defalias 'cl-ecase '(macro . #[385 "\300\301\302\"BB\207" [cl-case append ((cl--ecase-error-flag))] 7 (#$ . 19775)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-ecase lisp-indent-function 1 put edebug-form-spec cl-case] 5)
#@351 Eval EXPR and choose among clauses on that value.
Each clause looks like (TYPE BODY...).  EXPR is evaluated and, if it
satisfies TYPE, the corresponding BODY is evaluated.  If no clause succeeds,
this macro returns nil.  A TYPE of t or `otherwise' is allowed only in the
final clause, and matches if no other keys match.

(fn EXPR (TYPE BODY...)...)
(defalias 'cl-typecase '(macro . #[385 "\300!\203\n
\202
\301\302!\303C\304\305\306\307#\"B\262

=\203\"\207\310DC\"\207" [macroexp-copyable-p make-symbol "temp" nil cond mapcar make-closure #[257 "\211@\302=\203\303\202.\211@\304=\203\305\306\300\307\310\301\242!DF\202.\301
@\301\242B\240\210\311\300\307@DE
A\2064\312B\207" [V0 V1 otherwise t cl--ecase-error-flag error "cl-etypecase failed: %s, %s" quote reverse cl-typep (nil)] 7 "\n\n(fn C)"] macroexp-let*] 10 (#$ . 20146)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-typecase lisp-indent-function 1 put edebug-form-spec (form &rest ([&or cl-type-spec "otherwise"] body))] 5)
#@114 Like `cl-typecase', but error if no case fits.
`otherwise'-clauses are not allowed.

(fn EXPR (TYPE BODY...)...)
(defalias 'cl-etypecase '(macro . #[385 "\300\301\302\"BB\207" [cl-typecase append ((cl--ecase-error-flag))] 7 (#$ . 21182)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-etypecase lisp-indent-function 1 put edebug-form-spec cl-typecase] 5)
#@529 Define a lexically-scoped block named NAME.
NAME may be any symbol.  Code inside the BODY forms can call `cl-return-from'
to jump prematurely out of the block.  This differs from `catch' and `throw'
in two respects:  First, the NAME is an unevaluated symbol rather than a
quoted symbol or other form; and second, NAME is lexically rather than
dynamically scoped:  Only references to it within BODY will work.  These
references may appear inside macro expansions, but not inside functions
called from BODY.

(fn NAME &rest BODY)
(defalias 'cl-block '(macro . #[385 "\300\301B!\203\f\301
B\207\302\303\304\305\306\307\"!DBBD\207" [cl--safe-expr-p progn cl--block-wrapper catch quote intern format "--cl-block-%s--"] 9 (#$ . 21570)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-block lisp-indent-function 1 put edebug-form-spec (symbolp body)] 5)
#@110 Return from the block named nil.
This is equivalent to `(cl-return-from nil RESULT)'.

(fn &optional RESULT)
(defalias 'cl-return '(macro . #[256 "\300\301E\207" [cl-return-from nil] 4 (#$ . 22452)]))
(put 'cl-return 'edebug-form-spec '(&optional form))
#@327 Return from the block named NAME.
This jumps out to the innermost enclosing `(cl-block NAME ...)' form,
returning RESULT from that form (or nil if RESULT is omitted).
This is compatible with Common Lisp, but note that `defun' and
`defmacro' do not create implicit blocks as they do in Common Lisp.

(fn NAME &optional RESULT)
(defalias 'cl-return-from '(macro . #[513 "\300\301\302\"!\303\304DE\207" [intern format "--cl-block-%s--" cl--block-throw quote] 6 (#$ . 22714)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-return-from lisp-indent-function 1 put edebug-form-spec (symbolp &optional form)] 5)
#@22 

(fn KIND ITERATOR)
(defalias 'cl--loop-set-iterator-function #[514 "\203	\301\302\"\207\211\211\207" [cl--loop-iterator-function error "Iteration on %S does not support this combination"] 5 (#$ . 23351)])
#@1138 The Common Lisp `loop' macro.
Valid clauses include:
  For clauses:
    for VAR from/upfrom/downfrom EXPR1 to/upto/downto/above/below EXPR2
        [by EXPR3]
    for VAR = EXPR1 then EXPR2
    for VAR in/on/in-ref LIST [by FUNC]
    for VAR across/across-ref ARRAY
    for VAR being:
      the elements of/of-ref SEQUENCE [using (index VAR2)]
      the symbols [of OBARRAY]
      the hash-keys/hash-values of HASH-TABLE [using (hash-values/hash-keys V2)]
      the key-codes/key-bindings/key-seqs of KEYMAP [using (key-bindings VAR2)]
      the overlays/intervals [of BUFFER] [from POS1] [to POS2]
      the frames/buffers
      the windows [of FRAME]
  Iteration clauses:
    repeat INTEGER
    while/until/always/never/thereis CONDITION
  Accumulation clauses:
    collect/append/nconc/concat/vconcat/count/sum/maximize/minimize FORM
      [into VAR]
  Miscellaneous clauses:
    with VAR = INIT
    if/when/unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...]
    named NAME
    initially/finally [do] EXPRS...
    do EXPRS...
    [finally] return EXPR

For more details, see Info node `(cl)Loop Facility'.

(fn CLAUSE...)
(defalias 'cl-loop '(macro . #[128 "\306\307\310\311\312\311\306\313!\"\"\">\204\314\312\315\306BBE\207\211\312\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211 !\"#$%&'()\316)\317\"))@\320=\204]\321 \210\202O!\203l!\322BC'B'\n\203\203\n\323BC'B'\324\n\325BB%B%\f\237#\206\214$C\244\326&\237!\211A@%\237\244\316
\237\203\277\314\327@\306=\203\260\202\272\330@\331BBB!E\202\305\315@BBC!\203\345\332\232\203\327\"C\202\346\333!\334B\"FC\202\346#\"\203\364\"C'B''\2038
'@A\203
\335'\211A'\242\306#C\262
\202\364\312'\203-
'@A\204-
'\211A'\242@
B\262
\202
\335
\312#C\266\202\202\364	\203D
\336	BBC\262
\314(BB\266\204.\207" [cl--loop-conditions cl--loop-symbol-macs cl--loop-first-flag cl--loop-iterator-function cl--loop-finally cl--loop-initially t mapcar symbolp delq nil cl-copy-list cl-block while append (cl-end-loop) cl-end-loop cl--parse-loop-clause (t) (t) setq (nil) cl--loop-build-ands --cl-finish-- or ((cl-return-from --cl-finish-- nil)) (nil) if progn cl--loop-let cl-symbol-macrolet cl--loop-accum-vars cl--loop-accum-var cl--loop-finish-flag cl--loop-result-var cl--loop-result-explicit cl--loop-result cl--loop-steps cl--loop-body cl--loop-bindings cl--loop-name cl--loop-args] 18 (#$ . 23570)]))
(put 'cl-loop 'edebug-form-spec '(&rest &or [[&or "for" "as" "with" "and"] sexp] [[&or "from" "upfrom" "downfrom" "to" "upto" "downto" "above" "below" "by" "in" "on" "=" "across" "repeat" "while" "until" "always" "never" "thereis" "collect" "append" "nconc" "sum" "count" "maximize" "minimize" "if" "when" "unless" "return"] form] ["using" (symbolp symbolp)] symbolp form))
#@78 Apply CLAUSE to both `cl--loop-conditions' and `cl--loop-body'.

(fn CLAUSE)
(defalias 'cl--push-clause-loop-body '(macro . #[257 "\300
!\203\n\211\202
\301\302!\303\304\305BB\304\306BBE
=\203 \207\307DC\"\207" [macroexp-const-p make-symbol "sym" progn push (cl--loop-conditions) (cl--loop-body) macroexp-let*] 7 (#$ . 26402)]))
(defalias 'cl--parse-loop-clause #[0 "\211A\242C\306\307\204\310\311!\210\202-
\242\312=\203#\211A\242\202-
\242\313=\203Q@\314>\2036\210A@:\204@\310\315!\210@:\203-
\211A\242\nB\202@\242\316=\203\260@\317=\203nA@AA\206j\320\202-
@\321>\203z\210A@:\204\204\310\322!\210@@\317=\203\237	\204\237\211A\242A@\206\233\323\202-
@:\203-
\211A\242\fB\202\237\242\324>\203\273\325\211\211\211\211A\242\206\306\326\327!C\211A\242\240\210\242\330=\203\341\211A\242\240\210\242\331>\203\362\211A\242\240\210\242\332>\203
\333\240\210\334B\242\335>\203\242B\211@\336>\203
\310\337!\210@\340=\206(
\3418\342>@\343>\2064
\3418\344>@\345>\205B
A@AA@\346>\205P
A@AA@\347=\205^
A@AA\350!?\205h
\351\327!\350!?\205r
\351\327!\203\206
\247\203\206
\352X\203\206
\310\353\"\210\242\206\216
\352D\fB\262\f
\203\240

D\fB\262\f\211\203\254
\211D\fB\262\f\203\336
\203\301
\203\275
\354\202\312
\355\202\312
\203\311
\356\202\312
\357\242\206\322
E\211
B\211@B@\210\242\203\352
\360\202\353
\361	\242\206\367
\206\367
\362ED\nB\262\n\266\202E\242\363>\203\260\242\364=\211\203
\2429\203
\242\202\"\351\327!\211\211A\242DB\262\365
D\211
B\211@B@\210	\242\366=\203R\242\367DDABA\202u\211\242=\204u\242\325DB\262\242\203l
\202o\367DDB\262\211@\347=\203\243A@AA\211\242\370>\203\232\211A@9\203\232\211A@D\202\236\371
E\262
\202\246\372DDB\262\266\202E\242\373=\2034\211A\242@\374=\203\316A@AA\202\317\211B\206\332\351\327!\211B\242\325DB\262\204\356@\375=\203\242\376\242FDB\262\242\376\377
\237!@\242FDB\262\266\202E=\203\"\242D\202*\242\376FDB\262\266\202E\242\201I>\203\271\351\201J!\351\201K!
\211A\242DB\262\211\201LDB\262\201M
\201NDE@B@\356
\201ODE\211
B\211@B@\210	\242\201P=\203\235\242\201QEDABA\266\202E\242\325DB\262\242\201QEDB\262\266\202E\242\201R>\203\265@\201S>\206\333@\201T>?\205\333\310\201U!A@AA\351\201V!@\201W=\203A@G\341U\203A@@\201X=\203A@AAA@\202\310\201Y!\202\351\201K!
D	B\262	\211\352D	B\262	\203c\351\201Z!\211\201ODD\nB\262\n\242\201[EDABA\356E\211
B\211@B@\266\202\244\242\325D	B\262	\375\201\\\365D\356\201ODEEE\211
B\211@B@\210\242\376\365D\201]D\201QEFDB\262\211\201NDDB\262\266\202E\242>\203@@\201^>\204\315\310\201U!\210A@AA\211@\201W=\203A@G\341U\203A@@>\203A@@	\242=\204A@AAA@\202\310\201Y!\202\351\327!C	\242\201_>\203'
\242\242\240\210\240\210\201`\201a\201b\201c$\"\266\202E\242\201d>\203o@\201e>\205ZA@AA\201`\201f\201b\201g#\"\266\202E\242\201h>\203\334\325C\325C\325C@\201i>\203\301@\201j=\203\236
A@AA\240\210\202@\201k=\203\264\211A@AA\240\210\202A@AA\240\210\202\201`\201l\201b\201m%\"\266\202E\242\201n>\203\253\325C\325C\325C\325C\351\201o!C\351\201p!C@\201q>\203R@\201j=\203A@AA\240\210\202\372@\201k=\203/A@AA\240\210\202\372@\201r=\203EA@AA\240\210\202\372A@AA\240\210\202\372\242:\203z\242@9\203z\242A9\203z
\242@\240\210\211\242A\240\210\202\213\242\201s\242\242ED\nB\262\n\201`\201t\201b\201u						&\"\266\202E\242>\2038@\201v>\204\303\310\201U!\210A@AA\211@\201W=\203A@G\341U\203\375A@@>\203\375A@@	\242=\204\375A@AAA@\202\310\201Y!\202\351\327!C	\242\201w>\203
\242\242\240\210\240\210\201`\201x\201b\201y
%\"\266\202E\242\201z>\203\220\351\327!
\242\201{DB\262\211\325DB\262\201|\201}\201~\242ED\201\\\201M\242EEE\211
B\211@B@\210
\242\201\242DDB\262\210\202E\242\201\200>\203 @\201\201>\205\252A@AA\351\327!\351\201\202!\242\203\300\201\203D\202\303\201\204DB\262\211\201\205\201\206\242DDDB\262
\325DB\262\201|\201}\201~\242ED\201\\\201M	\242EEE\211
B\211@B@\210\242\201\207\242EDB\262\266\202E\2429\205.\242\201\210N\211\203;\211\242!\266\202E\310\201\211\n\242\"\266@\375=\262
\203\\\201\212\262
\210A\211\202\274\211\203n\203n\237CBC\202{\201\213\201\214\"C\244C\203\226\201\215\201\216\237\201M#\201\217BB@B@
\203\266\211\203\244\201\220\202\247\201M\201\221\201\222\237\"BDBD\266\202-
\242\201\223=\203\355\351\327!\211\211A\242DCCBC\355\201M\201\224DE\201\225BB@B@\210\202-
\242\201\226>\203D	\211A\242\201\227\325\201\230\"\211E=\203\"	\201\215\201\231E\201\232BB@B@\266\202-
\201\215\201M\201\233\201\214DEE\201\234BB@B@\266\202-
\242\201\235>\203\255	\211A\242\201\227\325\201\230\"\201\215\201M\211E=\203\206	\201\233\242\201\236>\203{	\201\230\202~	\201\237DE\202\235	\242\201\240>\203\226	\201\233\202\231	\201\222EE\201\241BB@B@\266\202-
\242\201\242>\203\335	\211A\242\201\227\201\243!\201\215\201\244\201\245F\201\246BB@B@\266\202-
\242\201\247>\203
\n\211A\242\201\227\201\250!\201\215\201\244\201\251F\201\252BB@B@\266\202-
\242\201\253>\2038\n\211A\242\201\227\352!\201\215\201\254E\201\255BB@B@\266\202-
\242\201\256>\203e\n\211A\242\201\227\352!\201\215\376\201\254DE\201\257BB@B@\266\202-
\242\201\260>\203\322\n\201\215\211A\242\201\261
!\203\202\n\211\202\207\n\351\201\262!\201\227\325!\201\263\201\264\242!\352\201\265O!\201M\376EFE\266\202
=\203\272\n\211\266\203\202\305\n\201\266DC\"\266\203\201\267BB@B@\202-
\242\201\270=\203\325\211A\242@\373=\205\357\nA@AAD
B\262
@\375=\203\210A\211\202\335\n\211\237CBC\210\202-
\242\201\271=\203%\211A\242@B@\202-
\242\201\272=\203?\201}\211A\242D@B@\202-
\242\201\273=\203lF\204T\351\201\274!F\201MF\211A\242E@B@\201\212G\202-
\242\201\275=\203\235F\204\201\351\201\274!F\201MF\201}\211A\242DE@B@\201\212G\202-
\242\201\276=\203\331F\204\262\351\201\274!FH\204\274\351\327!H\201MF\201}\201MH\211A\242EDE@B@\202-
\242\201\277>\203\240\f\211A\242\325@\201\300 \210\377@\237!)\325@@\201\301=\203\f\210A\201\300 \210\377@\237!)
@\201\212=\205 \f\211@\201\212=@\201\302=\203.\f\210A\242\201\303=\203>\f
\262\262\211\203L\f\201\215A@B\202O\f\3418
\203Y\fA@\202]\f\3418CB\201\304
\201\305\"\203~\f\201\306\201\305DC\376\201\305BBE\202\203\f\376BB\262

\203\225\f\201\215
\201\307BB\202\226\f\211@B@\266\202-
\242\201\310>\203\333\f\325@:\204\266\f\310\201\311!\210@:\203\310\f\211A\242
B\262
\202\266\f\201\215\201\212B\237B@B@\210\202-
\242\317=\203
F\204\354\f\351\327!FH\204\366\f\351\327!H\201MH\211A\242F\201\312BBBB@B@\202-
\2429\205
\242\201\313N\211\204)
\310\201\314\242\"\210\211 \266@\375=\205=
\210A\201\300 \207" [cl--loop-args cl--loop-name cl--loop-initially cl--loop-result-explicit cl--loop-finally cl--loop-conditions (hash-key hash-keys hash-value hash-values) (key-code key-codes key-seq key-seqs key-binding key-bindings) error "Malformed `cl-loop' macro" named initially (do doing) "Syntax error on `initially' clause" finally return 'nil (do doing) "Syntax error on `finally' clause" 'nil (for as) nil cl-gensym "--cl-var--" being (the each) (buffer buffers) in (buffer-list) (from downfrom upfrom to downto upto above below by) (downto above) "Must specify `from' value for downward cl-loop" downfrom 2 (downto above) (above below) (above below) (from upfrom downfrom) (to upto downto above below) by macroexp-const-p make-symbol 0 "Loop `by' value is not positive: %s" > >= < <= - + 1 (in in-ref on) on consp in-ref car (quote function cl-function) funcall cdr = then and if cl--loop-build-ands cl--loop-body cl--loop-symbol-macs cl--loop-first-flag cl--loop-bindings cl--loop-steps cl--loop-accum-var cl--loop-finish-flag cl--loop-result cl--loop-result-var (across across-ref) "--cl-vec--" "--cl-idx--" -1 setq 1+ length across-ref aref (element elements) (in-ref of-ref) (in of) "Expected `of'" "--cl-seq--" using index "Bad `using' clause" "--cl-len--" elt or pop (in of) (hash-value hash-values) cl--loop-set-iterator-function hash-tables make-closure #[257 "\303\304\300\242\302\242DBB\301E\207" [V0 V1 V2 maphash lambda] 5 "\n\n(fn BODY)"] (symbol present-symbol external-symbol symbols present-symbols external-symbols) (in of) symbols #[257 "\302\303\300\242CBB\301E\207" [V0 V1 mapatoms lambda] 5 "\n\n(fn BODY)"] (overlay overlays extent extents) (in of from to) from to overlays #[257 "\304\305\300\242\306\307!D\310B\311BBB\301\242\302\242\303\242\257\207" [V0 V1 V2 V3 cl--map-overlays lambda make-symbol "--cl-var--" progn (nil)] 6 "\n\n(fn BODY)"] (interval intervals) "--cl-var1--" "--cl-var2--" (in of property from to) property cons intervals #[257 "\306\307\304\242\305\242DBB\300\242\301\242\302\242\303\242\257\207" [V0 V1 V2 V3 V4 V5 cl--map-intervals lambda] 7 "\n\n(fn BODY)"] (in of) (key-binding key-bindings) keys #[257 "\300\242\304>\203\305\202\f\306\307\301\242\303\242DBB\302E\207" [V0 V1 V2 V3 (key-seq key-seqs) cl--map-keymap-recursively map-keymap lambda] 5 "\n\n(fn BODY)"] (frame frames screen screens) (selected-frame) prog1 not eq next-frame (window windows) (in of) "--cl-minip--" frame-selected-window (selected-window) minibufferp window-buffer next-window cl-loop-for-handler "Expected a `for' preposition, found %s" t mapcar list progn cl--loop-let (t) cl-psetq apply append repeat 1- (0) (collect collecting) cl--loop-handle-accum nreverse push (t) nconc (t) (nconc nconcing append appending) (nconc nconcing) reverse (nconc nconcing) (t) (concat concating) "" cl-callf concat (t) (vconcat vconcating) [] vconcat (t) (sum summing) cl-incf (t) (count counting) (t) (minimize minimizing maximize maximizing) macroexp-copyable-p "temp" intern symbol-name 3 macroexp-let* (t) with while until always "--cl-flag--" never thereis (if when unless) cl--parse-loop-clause else end unless cl--expr-contains it let (t) (do doing) "Syntax error on `do' clause" (nil) cl-loop-handler "Expected a cl-loop keyword, found %s"] 25])
#@12 

(fn SYM)
(defalias 'cl--unused-var-p #[257 "\211?\206\f\300
!\301H\302=\207" [symbol-name 0 95] 3 (#$ . 37034)])
#@333 Build an expression equivalent to (let SPECS BODY).
SPECS can include bindings using `cl-loop's destructuring (not to be
confused with the patterns of `cl-destructuring-bind').
If PAR is nil, do the bindings step by step, like `let*'.
If BODY is `setq', then use SPECS for assignments rather than for bindings.

(fn SPECS BODY PAR)
(defalias 'cl--loop-let #[771 "\301\211\203R\211\203 \211@\2429\204\211@A@\204 \211A\262
\202\211\203Q\301\262\211\203P\211@\302
A@!\204I\303\304!\211A@DB\262
A
\240\266
A\266\202\202(\210\210\203\341\211A\262\242\211\242
:\203\331\211:\204n\305
!\203\331\301\243@\306\307\"\305
!\203\200
\203\253\211\203\221\310=\203\243\305
!\203\243\303\304!\262
\310=\203\243\211CCB\211DB\262:\203\315\211A\262\242\205\305\203\302\311\202\303\312DDB\262\202\253\237\n\244\262\n\266\202R
B\266\203\202R\310=\203

\203\357\313\202\360\310\314\315\237\"B\203
\316\237E\207\207\203	
\317\202\n
\316\237\237\244BB\207" [cl--loop-bindings nil macroexp-const-p make-symbol "--cl-var--" cl--unused-var-p last 0 setq pop car cl-psetq apply nconc let* let] 13 (#$ . 37157)])
#@27 

(fn DEF &optional FUNC)
(defalias 'cl--loop-handle-accum #[513 "@\305=\203 A@AA\211	>\204\211DC\nB\211	B\207\206<\306\307!\211DC\nB\211\2039\211D\202:\207" [cl--loop-args cl--loop-accum-vars cl--loop-bindings cl--loop-accum-var cl--loop-result into make-symbol "--cl-var--"] 5 (#$ . 38325)])
#@292 Return various representations of (and . CLAUSES).
CLAUSES is a list of Elisp expressions, where clauses of the form
(progn E1 E2 E3 .. t) are the focus of particular optimizations.
The return value has shape (COND BODY COMBO)
such that COMBO is equivalent to (and . CLAUSES).

(fn CLAUSES)
(defalias 'cl--loop-build-ands #[257 "\300\211\203Z@\242\301=\203M\302@!@\303=\203MA\203?\304@!A@\242\301=\2031A@A\2025A@C\244AAB\262\202\304\211A\262\242!A\262
\202\211A\262\242B\262\202
\237\206a\303C\262
A\203n\305B\202p
@
\211\203\203\306\301\306\307\"BC\"\202\204\211A\203\217\305
B\202\221\211@\262
E\207" [nil progn last t butlast and append (t)] 11 (#$ . 38647)])
#@934 Bind variables and run BODY forms until END-TEST returns non-nil.
First, each VAR is bound to the associated INIT value as if by a `let' form.
Then, in each iteration of the loop, the END-TEST is evaluated; if true,
the loop is finished.  Otherwise, the BODY forms are evaluated, then each
VAR is set to the associated STEP expression (as if by a `cl-psetq' form)
and the next iteration begins.

Once the END-TEST becomes true, the RESULT forms are evaluated (with
the VARs still bound to their values) to produce the result
returned by `cl-do'.

Note that the entire loop is enclosed in an implicit nil block, so
that you can use `cl-return' to exit at any time.

Also note that END-TEST is checked before evaluating BODY.  If END-TEST
is initially non-nil, `cl-do' will exit without running BODY.

For more details, see `cl-do' description in Info node `(cl) Iteration'.

(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)
(defalias 'cl-do '(macro . #[642 "\300\301$\207" [cl--expand-do-loop nil] 8 (#$ . 39358)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-do lisp-indent-function 2 put edebug-form-spec ((&rest &or symbolp (symbolp &optional form form)) (form body) cl-declarations body)] 5)
#@978 Bind variables and run BODY forms until END-TEST returns non-nil.
First, each VAR is bound to the associated INIT value as if by a `let*' form.
Then, in each iteration of the loop, the END-TEST is evaluated; if true,
the loop is finished.  Otherwise, the BODY forms are evaluated, then each
VAR is set to the associated STEP expression (as if by a `setq'
form) and the next iteration begins.

Once the END-TEST becomes true, the RESULT forms are evaluated (with
the VARs still bound to their values) to produce the result
returned by `cl-do*'.

Note that the entire loop is enclosed in an implicit nil block, so
that you can use `cl-return' to exit at any time.

Also note that END-TEST is checked before evaluating BODY.  If END-TEST
is initially non-nil, `cl-do*' will exit without running BODY.

This is to `cl-do' what `let*' is to `let'.
For more details, see `cl-do*' description in Info node `(cl) Iteration'.

(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)
(defalias 'cl-do* '(macro . #[642 "\300\301$\207" [cl--expand-do-loop t] 8 (#$ . 40598)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-do* lisp-indent-function 2 put edebug-form-spec cl-do] 5)
#@32 

(fn STEPS ENDTEST BODY STAR)
(defalias 'cl--expand-do-loop #[1028 "\300\301\203\n\302\202\303\304\305\"\306\307@D\310\304\311
\"\312\301\"\262
\211\205=	\2042\211A\2046\313\2027\314\315\310\"BC\262
\"BBA\206I\316BBBE\207" [cl-block nil let* let mapcar #[257 "\211:\203\f\211@
A@D\207\207" [] 3 "\n\n(fn C)"] while not append #[257 "\211:\205\211AA\205\211@\3008D\207" [2] 4 "\n\n(fn C)"] delq setq cl-psetq apply (nil)] 17 (#$ . 41802)])
#@225 Loop over a list.
Evaluate BODY with VAR bound to each `car' from LIST, in turn.
Then evaluate RESULT to get return value, default nil.
An implicit nil block is established around the loop.

(fn (VAR LIST [RESULT]) BODY...)
(defalias 'cl-dolist '(macro . #[385 "\300BB\301\302\300\"\203
\207\303\304E\207" [dolist advice-member-p cl--wrap-in-nil-block cl-block nil] 6 (#$ . 42276)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put cl-dolist edebug-form-spec ((symbolp form &optional form) cl-declarations body) function-put lisp-indent-function 1] 4)
#@216 Loop a certain number of times.
Evaluate BODY with VAR bound to successive integers from 0, inclusive,
to COUNT, exclusive.  Then evaluate RESULT to get return value, default
nil.

(fn (VAR COUNT [RESULT]) BODY...)
(defalias 'cl-dotimes '(macro . #[385 "\300BB\301\302\300\"\203
\207\303\304E\207" [dotimes advice-member-p cl--wrap-in-nil-block cl-block nil] 6 (#$ . 42856)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put cl-dotimes edebug-form-spec cl-dolist function-put lisp-indent-function 1] 4)
(defvar cl--tagbody-alist nil)
#@603 Execute statements while providing for control transfers to labels.
Each element of LABELS-OR-STMTS can be either a label (integer or symbol)
or a `cons' cell, in which case it's taken to be a statement.
This distinction is made before performing macroexpansion.
Statements are executed in sequence left to right, discarding any return value,
stopping only when reaching the end of LABELS-OR-STMTS.
Any statement can transfer control at any time to the statements that follow
one of the labels with the special form (go LABEL).
Labels have lexical scope and dynamic extent.

(fn &rest LABELS-OR-STMTS)
(defalias 'cl-tagbody '(macro . #[128 "\302
@:\203\303\202
\211A\262\242\211C\211\203G\211@\211:\203'\211B\262\202@\242\242\304=\2046\304
DB\262\237B\262\211C\262
A\266\202\202\210\211\242\242\304=\204U\305
B\262
\211\237B\262\210\306\307!\310
BB\211\203|\211@\211@BB
A\266\202\202h\210\311\312\313\314DDC\315\316\317\320\313\321\314\nD\322\313BBEE\323BBDDE\304\324B	B\")\207" [cl--tagbody-alist macroexpand-all-environment nil cl--preamble go (go cl--exit) make-symbol "cl--tagbody-tag" cl--exit macroexpand-all let next-label quote while not eq setq catch cl-case ('cl--exit) #[257 "\211\236A\211\204
\301\302\"\210\303\304D\304DE\207" [cl--tagbody-alist error "Unknown cl-tagbody go label `%S'" throw quote] 6 "\n\n(fn LABEL)"]] 17 (#$ . 43418)]))
#@29 

(fn BINDER BINDINGS BODY)
(defalias 'cl--prog #[771 "\300
@\242\301=\203
\211A\262\242
B\262
\202
\302\300\303\237\304BC\"BBE\207" [nil declare cl-block append cl-tagbody] 12 (#$ . 44820)])
#@149 Run BODY like a `cl-tagbody' after setting up the BINDINGS.
Shorthand for (cl-block nil (let BINDINGS (cl-tagbody BODY)))

(fn BINDINGS &rest BODY)
(defalias 'cl-prog '(macro . #[385 "\300\301#\207" [cl--prog let] 6 (#$ . 45028)]))
#@150 Run BODY like a `cl-tagbody' after setting up the BINDINGS.
Shorthand for (cl-block nil (let* BINDINGS (cl-tagbody BODY)))

(fn BINDINGS &rest BODY)
(defalias 'cl-prog* '(macro . #[385 "\300\301#\207" [cl--prog let*] 6 (#$ . 45269)]))
#@149 Loop over all symbols.
Evaluate BODY with VAR bound to each interned symbol, or to each symbol
from OBARRAY.

(fn (VAR [OBARRAY [RESULT]]) BODY...)
(defalias 'cl-do-symbols '(macro . #[385 "\300\301\302@C\303\304\305@CBBDA@\205A@CBB\3068FE\207" [cl-block nil let mapatoms function lambda 2] 11 (#$ . 45513)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-do-symbols lisp-indent-function 1 put edebug-form-spec ((symbolp &optional form form) cl-declarations def-body)] 5)
#@81 Like `cl-do-symbols', but use the default obarray.

(fn (VAR [RESULT]) BODY...)
(defalias 'cl-do-all-symbols '(macro . #[385 "\300@\301A@EBB\207" [cl-do-symbols nil] 6 (#$ . 46027)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-do-all-symbols lisp-indent-function 1 put edebug-form-spec ((symbolp &optional form) cl-declarations body)] 5)
#@202 Set SYMs to the values VALs in parallel.
This is like `setq', except that all VAL forms are evaluated (in order)
before assigning any symbols SYM to the corresponding values.

(fn SYM VAL SYM VAL ...)
(defalias 'cl-psetq '(macro . #[128 "\300
B\207" [cl-psetf] 3 (#$ . 46401)]))
(put 'cl-psetq 'edebug-form-spec 'setq)
#@438 Bind SYMBOLS to VALUES dynamically in BODY.
The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
Each symbol in the first list is bound to the corresponding value in the
second list (or to nil if VALUES is shorter than SYMBOLS); then the
BODY forms are executed and their result is returned.  This is much like
a `let' form, except that the list of symbols can be computed at run-time.

(fn SYMBOLS VALUES &rest BODY)
(defalias 'cl-progv '(macro . #[642 "\300\301!\300\302!\300\303!\300\304!\305\306	D	D\307\310BBD\311BF\312\313\314\315	D\314\316\315DEE	EE\317\314\320\321\nD\314\322\314\323EEFDFD\207" [make-symbol "body" "binds" "syms" "vals" progn let* lambda nil (nil) while push list pop 'quote eval 'let nreverse 'funcall 'quote] 20 (#$ . 46727)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-progv lisp-indent-function 2 put edebug-form-spec (form form def-body)] 5)
(defconst cl--labels-magic (make-symbol "cl--labels-magic"))
(defvar cl--labels-convert-cache nil)
#@82 Special macro-expander to rename (function F) references in `cl-labels'.

(fn F)
(defalias 'cl--labels-convert #[257 "\211@=\203\nA\207\211	\236\211\205\3031\211A\n!0\202\210\304\211\203.\n
@=\203.\211A@\207\305D
B\207" [cl--labels-convert-cache macroexpand-all-environment cl--labels-magic (error) nil function] 6 (#$ . 47768)])
#@531 Make local function definitions.
Each definition can take the form (FUNC EXP) where
FUNC is the function name, and EXP is an expression that returns the
function value to which it should be bound, or it can take the more common
form (FUNC ARGLIST BODY...) which is a shorthand
for (FUNC (lambda ARGLIST BODY)).

FUNC is defined only within FORM, not BODY, so you can't write
recursive function definitions.  Use `cl-labels' for that.  See
info node `(cl) Function Bindings' for details.

(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-flet '(macro . #[385 "\301\211\203U\211@\302\303\304@\"!C
A\211G\305U\203(\211@9\203(

@\240\210\202A
\242
G\305U\2036
@\202;\306\307BDDB\262@\310\311\"BB\262\266
A\266\202\202\210\312\237\313\314B\315\236\203h\202m\315\316BB\"\"\207" [macroexpand-all-environment nil make-symbol format "--cl-%s--" 1 cl-function lambda make-closure #[128 "\211@	=\203\f	\300\242D\207\302\300\242BB\207" [V0 cl--labels-magic funcall] 4 "\n\n(fn &rest ARGS)"] macroexp-let* macroexpand-all progn function cl--labels-convert] 12 (#$ . 48119)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-flet lisp-indent-function 1 put edebug-form-spec ((&rest [&or (symbolp form) (&define [&name symbolp "@cl-flet@"] [&name [] gensym] cl-lambda-list cl-declarations-or-string [&optional ("interactive" interactive)] def-body)]) cl-declarations body)] 5)
#@140 Make local function definitions.
Like `cl-flet' but the definitions can refer to previous ones.

(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-flet* '(macro . #[385 "
\204\300
!\207
A\204\301BB\207\301\211A\262\242C\302BBE\207" [macroexp-progn cl-flet cl-flet*] 7 (#$ . 49546)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-flet* lisp-indent-function 1 put edebug-form-spec cl-flet] 5)
#@23 

(fn VAR FARGS BODY)
(defalias 'cl--self-tco #[771 "\300C\301\302!\303\304\"\300C\300C
\305\306\"\240\210\211\305\307\n&\240\210
\242!\242\2047B\207\310C\311\310\312\300\313\314
#\"BBDFCB\207" [nil make-symbol "retval" mapcar #[257 "\211>\203\207\301\302!!\207" [cl--lambda-list-keywords make-symbol symbol-name] 4 "\n\n(fn S)"] make-closure #[257 "\301\302!\300\242\303!@!C\"\207" [V0 append butlast last] 6 "\n\n(fn EXPS)"] #[257 "\306
:\203\272

\242\211\307\267\202\265
\243\211:\203q\211\242\300
=\203k
\243\211\310\303\211\203^\211
A\262\242\211\311\267\202K
\211A\262\242B\262\312BB\262\210\202\"\210\202\"\211B\262\211A\262\242B\262\210\202\"\301\313\240\210\314\315\237B\316BB\207\302\"\207\302\"\207\243\314\304\242!B\207\243\211:\203\247\211\242
\243\211:\203\241\211\242
\243\317\305\242!\304\242!BBB\207\302\"\207\302\"\207\243\320\304\242!B\207\243\211:\203\341\211\242
\243\211\204\311\305\242!\207\321\322!\323
DC\317\305\242!\305\242\324B!FE\207\302\"\207\243\211\310C
\2036
\325\211A\262\242\211:\203,
\211\242
\243\211\204!
\203
\315\302E\326B\202
\305\242!C\242B\240\266\202\353\304#\266\202\353
\304#\266\202\353\327
\242\237B\207\243\211:\203d
\211\242
\243\330\331\"\300
>?\262
\203^
@\304\242!BB\207\302\"\207\302\"\207\243\211:\203\260
\211\242
\243\211:\203\252
\211\242
\243\300=\204\243
\332\333\236\203\217
\202\230
\314\315\302E\334BB\330\335\336\304\"\"BBB\207\302	\"\207\302\"\207\302\"\207
\302\"\207
\204\300
\310\207\211\302\"\207" [V0 V1 V2 V3 V4 V5 #[514 "\300\301E\302BB\207" [progn setq (nil)] 6 "\n\n(fn RETVAR EXP)"] #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (funcall 14 progn 118 if 127 and 172 or 181 cond 230 let* 316 let 316 condition-case 361)) nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (&rest 50 &optional 71)) list t progn setq (:recurse) if and make-symbol "val" let or #[771 "
\242!\242B\240\207" #1=[] 6 "\n\n(fn OPT-EXPS CS EXPS)"] (nil) cond mapcar #[257 "\211:\203\211@\207\207" #1# 2 "\n\n(fn B)"] condition-case :success (nil) make-closure #[257 "\211@\300\242A!B\207" [V0] 4 "\n\n(fn H)"]] 15 "\n\n(fn EXP)"] let while delq cl-mapcar #[514 "
>?\205\n

D\207" [cl--lambda-list-keywords] 4 "\n\n(fn A OA)"]] 20 (#$ . 49983)])
#@428 Make local (recursive) function definitions.
+BINDINGS is a list of definitions of the form (FUNC ARGLIST BODY...) where
FUNC is the function name, ARGLIST its arguments, and BODY the
forms of the function body.  FUNC is defined in any BODY, as well
as FORM, so you can write recursive and mutually recursive
function definitions.  See info node `(cl) Function Bindings' for
details.

(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-labels '(macro . #[385 "\301C\211\203.\211@\302\303\304@\"!\211ABB\262@\305\306\"B\242B\240\266
A\266\202\202\210\307
\242\236\204?\211\307\310B\242B\240\210\311\305\312\"\237\"\262\313\314\315\316!\242\"!BB\207" [macroexpand-all-environment nil make-symbol format "--cl-%s--" make-closure #[128 "\211@	=\203	\300D\207\302\300BB\207" [V0 cl--labels-magic funcall] 4 "\n\n(fn &rest ARGS)"] function cl--labels-convert mapcar #[257 "\211\242
\243\211\242
\243\301\302\303BBD\300\242\"\211\242
\243\211\242\211\242
\243\211\242
\243\243\304
#\211\242
\243\305\303BBDD\207" [V0 macroexpand-all cl-function lambda cl--self-tco function] 22 "\n\n(fn BIND)"] letrec macroexp-unprogn macroexpand-all macroexp-progn] 12 (#$ . 52415)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-labels lisp-indent-function 1 put edebug-form-spec cl-flet] 5)
#@32 

(fn BINDINGS PF &rest SPECS)
(defalias 'cl--edebug-macrolet-interposer #[642 "@\262\301\302\"\244

!)\207" [edebug-lexical-macro-ctx mapcar #[257 "\211@\3008\242\301=\205\302\3008A\236A@B\207" [2 declare debug] 5 "\n\n(fn BINDING)"]] 6 (#$ . 53757)])
#@139 Make temporary macro definitions.
This is like `cl-flet', but for macros instead of functions.

(fn ((NAME ARGLIST BODY...) ...) FORM...)
(defalias 'cl-macrolet '(macro . #[385 "
A\203\301@C\301ABBE\207
\204\302
!\207
@@\303@A\"\304\302!\305\306\307BD\310\"BB\"\207" [macroexpand-all-environment cl-macrolet macroexp-progn cl--transform-lambda macroexpand-all eval function lambda t] 11 (#$ . 54026)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-macrolet lisp-indent-function 1 put edebug-form-spec (&interpose (&rest (&define [&name symbolp "@cl-macrolet@"] [&name [] gensym] cl-macro-list cl-declarations-or-string def-body)) cl--edebug-macrolet-interposer cl-declarations body)] 5)
#@219 Special macro expander advice used inside `cl-symbol-macrolet'.
This function extends `macroexpand' during macro expansion
of `cl-symbol-macrolet' to additionally expand symbol macros.

(fn ORIG-FUN EXP &optional ENV)
(defalias 'cl--sm-macroexpand #[770 "\211C\211\242\301\302\242\"
\242\"\2629\203)
\236\211\205$\211A@\211\262\262
\202!:\203$\242\211\303\267\202\243\211\304\211\203v\211A\262\242\211\236\211\205_\211A@\262
9\203[\305\202_\305\262\304\262
\204E\211B\262\211A\262\242B\266\202\202;
\203~\306\202\307
\237B\262\n
\266\202\262
\262
\202\243\211\242
\243\304\211\211\203
\211@\2119\203\246\211\202\250\211@\205\302
:\205\302
@\310=\205\302\311A@
\242\"C
\236\203\362\312\313!!\305\262
D\fB\262\f
\302
B\242B\240\210\211\206\354\243B\262
\202\375\211\203\374

B\202\375B\262\266
A\266\202\202\227\210\211\203$
\n@\237\314\311\315!
\242\"!BB\262\266\304\262
\202\243\211:\205\276
\211\242\211:\205\274
\211\242\211\316=\205\272

\243\211:\205\270
\211\242
\243\243\211?\205\266
\304\211\211\203\234
\211@\211\317>\203g
\211\202\221
\211
\236\203\220
\312\313!!\305\262

DB\262\302B\242B\240\210\211\262
\202\221
\211B\262
A\266\202\202W
\210\211\203\263
\320\316\237\321\322\323\"\"BBD\262\266\304\266\203\262
\262
\262
\262
\202\243\211:\205\211\242
\243\211:\205\211\242
\243\236\205
\312\313!!
D	B\262	\n\302\nB\f\242B\240\210\324
\311\242\"\321\322\325\"\"BBB\262\304\262
\262
\266\202\266\202\262
\202\304\262
\204)\207" [macroexpand-all-environment alist-get :cl-symbol-macros #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (setq 54 let* 142 let 142 function 300 condition-case 451)) nil t setf setq let* macroexpand-all make-symbol symbol-name macroexp-unprogn macroexp-progn lambda (&optional &rest) function mapcar make-closure #[257 "\301
\300\242\"\207" [V0 macroexpand-all] 4 "\n\n(fn EXP)"] condition-case #[257 "\211@\301\302\303\300\"A\"B\207" [V0 mapcar make-closure #[257 "\301
\300\242\"\207" [V0 macroexpand-all] 4 "\n\n(fn EXP)"]] 6 "\n\n(fn CLAUSE)"]] 23 (#$ . 54758)])
#@211 Make symbol macro definitions.
Within the body FORMs, references to the variable NAME will be replaced
by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).

(fn ((NAME EXPANSION) ...) FORM...)
(defalias 'cl-symbol-macrolet '(macro . #[385 "\301\302\303\304\"\211\203/\211@\211:\203#\211@9\203#\211A:\203#\211AA\203(\211B\262
A\266\202\202\210\305\306\"\216\211\204?\307\304\310\303#\210\311\236A\312\313!\311\314\"BB\"\203c\315\316\317\237\"\"\266\202\202f\211\266\202)\207" [macroexpand-all-environment nil advice-member-p cl--sm-macroexpand macroexpand make-closure #[0 "\300?\205	\301\302\303\"\207" [V0 advice-remove macroexpand cl--sm-macroexpand] 3] advice-add :around :cl-symbol-macros macroexpand-all macroexp-progn append macroexp-warn-and-return format-message "Malformed `cl-symbol-macrolet' binding(s): %S"] 11 (#$ . 56949)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-symbol-macrolet lisp-indent-function 1 put edebug-form-spec ((&rest (symbolp sexp)) cl-declarations body)] 5)
#@393 Collect multiple return values.
FORM must return a list; the BODY is then executed with the first N elements
of this list bound (`let'-style) to each of the symbols SYM in turn.  This
is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
simulate true multiple return values.  For compatibility, (cl-values A B C) is
a synonym for (list A B C).

(fn (SYM...) FORM BODY)
(defalias 'cl-multiple-value-bind '(macro . #[642 "\300\301!\302C\303D\304\305\306#\"BBB\207" [make-symbol "--cl-var--" -1 let* mapcar make-closure #[257 "\211\302\301\211\242T\240\300ED\207" [V0 V1 nth] 5 "\n\n(fn V)"]] 12 (#$ . 58016)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-multiple-value-bind lisp-indent-function 2 put edebug-form-spec ((&rest symbolp) form body)] 5)
#@348 Collect multiple return values.
FORM must return a list; the first N elements of this list are stored in
each of the symbols SYM in turn.  This is analogous to the Common Lisp
`multiple-value-setq' macro, using lists to simulate true multiple return
values.  For compatibility, (cl-values A B C) is a synonym for (list A B C).

(fn (SYM...) FORM)
(defalias 'cl-multiple-value-setq '(macro . #[514 "
\204\n\300
\301BB\207
A\204\302@\303DE\207\304\305!\306C\307DC\310\302\211A\262	\242\303DE\302\311\312\313\314\315#\f\"\"BEE\207" [progn (nil) setq car make-symbol "--cl-var--" 0 let prog1 apply nconc mapcar make-closure #[257 "\211\302\301\211\242T\240\300ED\207" [V0 V1 nth] 5 "\n\n(fn V)"]] 16 (#$ . 58829)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-multiple-value-setq lisp-indent-function 1 put edebug-form-spec ((&rest symbolp) form)] 5)
#@41 Equivalent to `progn'.

(fn &rest BODY)
(defalias 'cl-locally '(macro . #[128 "\300
B\207" [progn] 3 (#$ . 59723)]))
(put 'cl-locally 'edebug-form-spec t)
#@87 Return FORM.  If type-checking is enabled, assert that it is of TYPE.

(fn TYPE FORM)
(defalias 'cl-the '(macro . #[514 "\303\300!\203\203
\304\267\202\305
D\202\306
D\202\211\262
\307 \2031	\310W\2041\n\310U\2041\207\311
!\203;\211\202>\312\313!\314\315\316\317DE\320\321\322\317	D\317\nDFEEE
=\203`\207\323DC\"\207" [byte-native-compiling cl--optimize-speed cl--optimize-safety boundp #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (fixnum 16 cons 22)) comp-hint-fixnum comp-hint-cons macroexp-compiling-p 3 macroexp-copyable-p make-symbol "temp" progn unless cl-typep quote signal 'wrong-type-argument list macroexp-let*] 13 (#$ . 59884)]))
(byte-code "\302\303\304\305#\306\303\307\310#\210\311\236\204\311\312D\211	B\211B\210\302\207" [defun-declarations-alist macro-declarations-alist function-put cl-the lisp-indent-function 1 put edebug-form-spec (cl-type-spec form) cl-optimize cl--optimize] 5)
#@152 Serve 'cl-optimize' in function declarations.
Example:
(defun foo (x)
  (declare (cl-optimize (speed 3) (safety 0)))
  x)

(fn F ARGS &rest QUALITIES)
(defalias 'cl--optimize #[642 "\211\302\211\211:\203=@\262
\211
A\262\242\262\211@\262\303\267\2020
\304\302#\210\2026
\2026\305\306\307#\210A\262\202\302\207" [cl--optimize-speed cl--optimize-safety nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (speed 31 safety 43)) byte-run--set-speed error "cl-ecase failed: %s, %s" (speed safety)] 11 (#$ . 60868)])
(defvar cl--proclaim-history t)
(defvar cl--declare-stack t)
#@18 

(fn SPEC HIST)
(defalias 'cl--do-proclaim #[514 "\211\203
<\203

B
\242\306=\203#\307\301!\203\325\310A	\"\202\325
\242\311=\203K
A\211\262\203\325
@\312N\313>\204A\314\315@\"\210\316@\312\317#\210\202*
\242\320=\203m
A\211\262\203\325
@\312N\317=\203R\316@\312\321#\210\202R
\242\322=\203\237\323A\236A@\324\236\325A\236A@\326\236
\203\217
@
A@\211\203\232\211@\211A@\266\202\325
\242\327=\203\325\307\330!\203\325
A\211\262\203\325
@:\203\254
@A@\331=\203\314\332@@!\210\202\254\333@@!\210\202\254\321\207" [cl--proclaim-history byte-compile-bound-variables cl--optimize-speed byte-optimize cl--optimize-safety byte-compile-delete-errors special boundp append inline byte-optimizer (nil byte-compile-inline-expand) error "%s already has a byte-optimizer, can't make it inline" put byte-compile-inline-expand notinline nil optimize speed ((0 nil) (1 t) (2 t) (3 t)) safety ((0 t) (1 t) (2 t) (3 nil)) warn byte-compile-warnings 0 byte-compile-disable-warning byte-compile-enable-warning] 6 (#$ . 61503)])
(byte-code "\301!\211\203\302
\211A\262\242\303\"\210\202\304\207" [cl--proclaims-deferred reverse cl--do-proclaim t nil] 4)
#@215 Declare SPECS about the current function while compiling.
For instance

  (cl-declare (warn 0))

will turn off byte-compile warnings in the function.
See Info node `(cl)Declarations' for details.

(fn &rest SPECS)
(defalias 'cl-declare '(macro . #[128 "\301 \203 \211\203 <\203\211@B\302
\211A\262\242\303\"\210\202\303\207" [cl--declare-stack macroexp-compiling-p cl--do-proclaim nil] 4 (#$ . 62694)]))
#@203 Set PLACEs to the values VALs in parallel.
This is like `setf', except that all VAL forms are evaluated (in order)
before assigning any PLACEs to the corresponding values.

(fn PLACE VAL PLACE VAL ...)
(defalias 'cl-psetf '(macro . #[128 "\211\300\301\203?@9\203\302A@\"\203\301\262@
>\203&\303\304@\"\210\211A\262\242
B\262
\2048\303\305!\210A\262\202
\203K\306\307B\310BB\207\311!\262\312A@@EAA\211\262\203p\312A@\313@EE\262
\202W\306
\314BB\207" [t nil cl--expr-depends-p error "Destination duplicated in psetf: %s" "Odd number of arguments to cl-psetf" progn setq (nil) reverse setf prog1 (nil)] 10 (#$ . 63115)]))
(put 'cl-psetf 'edebug-form-spec 'setf)
#@191 Remove TAG from property list PLACE.
PLACE may be a symbol, or any generalized variable allowed by `setf'.
The form returns true if TAG was found and removed, nil otherwise.

(fn PLACE TAG)
(defalias 'cl-remf '(macro . #[514 "\300\301\302\"\"\207" [gv-get make-closure #[514 "\300\301
!\203\211\202\302\303!\304\305\306DE\307\310D!\311BB\312EF
=\203-\207\313DC\"\207" [V0 macroexp-copyable-p make-symbol "ttag" if eq car progn cddr (t) cl--do-remf macroexp-let*] 10 "\n\n(fn TVAL SETTER)"]] 7 (#$ . 63816)]))
(put 'cl-remf 'edebug-form-spec '(place form))
#@191 Shift left among PLACEs.
Example: (cl-shiftf A B C) sets A to B, B to C, and returns the old A.
Each PLACE may be a symbol, or any generalized variable allowed by `setf'.

(fn PLACE... VAL)
(defalias 'cl-shiftf '(macro . #[385 "\211\204
\207
9\203\300\301\302BEE\207\303\304\305\"\"\207" [prog1 setq cl-shiftf gv-get make-closure #[514 "\301\302\300B!E\207" [V0 prog1 cl-shiftf] 7 "\n\n(fn GETTER SETTER)"]] 8 (#$ . 64399)]))
(put 'cl-shiftf 'edebug-form-spec '(&rest place))
#@195 Rotate left among PLACEs.
Example: (cl-rotatef A B C) sets A to B, B to C, and C to A.  It returns nil.
Each PLACE may be a symbol, or any generalized variable allowed by `setf'.

(fn PLACE...)
(defalias 'cl-rotatef '(macro . #[128 "\300\301\302\">\2040\211A\205Z\300
@A\203&
\211A\262\242@D\244\262\202\303\304@D\"B\207\305
!\306\307!\211CA\203O\211\310\211A\262\242\311\312\"\"\240\210\2028\310@\311\313#\"\266\203\207" [nil mapcar symbolp cl-psetf append reverse make-symbol "--cl-rotatef--" gv-get make-closure #[514 "\301\300\242!E\207" [V0 prog1] 6 "\n\n(fn GETTER SETTER)"] #[514 "\302\300DC\303\301\242!\304BB\"\207" [V0 V1 macroexp-let* progn (nil)] 7 "\n\n(fn GETTER SETTER)"]] 10 (#$ . 64893)]))
(put 'cl-rotatef 'edebug-form-spec '(&rest place))
#@40 

(fn BINDINGS SIMPLEBINDS BINDS BODY)
(defalias 'cl--letf #[1028 "\2040
\204\204\301
!\207\302\303\304\305\"\"\306\301\303\307\310\304\311\n\"\"\"!\304\312\"BBE\207@\313
@\"\314
\315\316						&\"\207" [macroexpand-all-environment macroexp-progn let* append mapcar #[257 "\211\242
\243\211\242
\243\211\242
\243\211\242
\243\300\211	D\207" [nil] 13 "\n\n(fn X)"] unwind-protect delq nil #[257 "\211:\2058\211\242
\243\211:\2056\211\242
\243\211:\2054\211\242
\243\211:\2052\211\242
\243\211?\2050\300\211!\266\202\266\202\266\202\266\202\266\202\207" [nil] 13 "\n\n(fn X)"] #[257 "\211\242
\243\211\242
\243\211\242
\243\211\242
\243\300\211\n!\207" [nil] 13 "\n\n(fn X)"] macroexpand gv-get make-closure #[514 "\304A@\306
!\203
\211\202\307\310!\3059\203-\311\300A\304A\203\"\202$D\301B\302\303$\202G\311\300A\301\307\312!\304A\205@CBBB\302B\303$
=\203N\207\313DC\"\207" [V0 V1 V2 V3 V4 V5 macroexp-const-p make-symbol "vnew" cl--letf "old" macroexp-let*] 11 "\n\n(fn GETTER SETTER)"]] 16 (#$ . 65684)])
#@584 Temporarily bind to PLACEs.
This is the analogue of `let', but with generalized variables (in the
sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
VALUE, then the BODY forms are executed.  On exit, either normally or
because of a `throw' or error, the PLACEs are set back to their original
values.  Note that this macro is *not* available in Common Lisp.
As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
the PLACE is not modified before executing BODY.

See info node `(cl) Function Bindings' for details.

(fn ((PLACE VALUE) ...) BODY...)
(defalias 'cl-letf '(macro . #[385 "
A\204#
@A\203#
@@9\203#
@@\301\302\"\236\204#\303BB\207\304\305\211$\207" [macroexpand-all-environment alist-get :cl-symbol-macros let cl--letf nil] 7 (#$ . 66754)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-letf lisp-indent-function 1 put edebug-form-spec ((&rest [&or (symbolp form) (gate gv-place &optional form)]) body)] 5)
#@192 Temporarily bind to PLACEs.
Like `cl-letf' but where the bindings are performed one at a time,
rather than all at the end (i.e. like `let*' rather than like `let').

(fn BINDINGS &rest BODY)
(defalias 'cl-letf* '(macro . #[385 "\300!\211\203\211@\301
CBBC\262
A\266\202\202\210\302
!\207" [reverse cl-letf macroexp-progn] 7 (#$ . 67746)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-letf* lisp-indent-function 1 put edebug-form-spec cl-letf] 5)
#@199 Set PLACE to (FUNC PLACE ARGS...).
FUNC should be an unquoted function name or a lambda expression.
PLACE may be a symbol, or any generalized variable allowed by
`setf'.

(fn FUNC PLACE &rest ARGS)
(defalias 'cl-callf '(macro . #[642 "\300\301\302#\"\207" [gv-get make-closure #[514 "
\301B
\3009\203\300B\202\302\303\300DBB!\207" [V0 V1 funcall function] 7 "\n\n(fn GETTER SETTER)"]] 9 (#$ . 68231)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-callf lisp-indent-function 2 put edebug-form-spec (cl-function place &rest form)] 5)
#@145 Set PLACE to (FUNC ARG1 PLACE ARGS...).
Like `cl-callf', but PLACE is the second argument of FUNC, not the first.

(fn FUNC ARG1 PLACE ARGS...)
(defalias 'cl-callf2 '(macro . #[899 "\300!\203\301!\2039\203\302BBBE\207\303!\203&\202)\304\305!\306\307\310$\"
=\203<\207\311DC\"\207" [cl--safe-expr-p cl--simple-expr-p setf macroexp-const-p make-symbol "a1" gv-get make-closure #[514 "\302\301BB
\3009\203\300B\202\303\304\300DBB!\207" [V0 V1 V2 funcall function] 7 "\n\n(fn GETTER SETTER)"] macroexp-let*] 12 (#$ . 68805)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl-callf2 lisp-indent-function 3 put edebug-form-spec (cl-function form place &rest form)] 5)
#@329 Define NAME as a function.
Like `defun', except the function is automatically declared `inline' and
the arguments are immutable.
ARGLIST allows full Common Lisp conventions, and BODY is implicitly
surrounded by (cl-block NAME ...).
The function's arguments should be treated as immutable.

(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defsubst '(macro . #[642 "\300!@\301=\203AA\202
\211\203'\302@\"\303=\203'\211A\262
\202\304
?\205p\305\306>\203B\307\310\311\nBBB\202F\311B\312\313\"\314\315	D\315\316\317!ABBD\320\306>\205e\310\320
BBBBBB\257\321BBBE\207" [cl--arglist-args &cl-defs cl--expr-contains 1 progn cl-define-compiler-macro &key &whole cl-whole &cl-quote format "compiler-macro for inlining `%s'." cl--defsubst-expand quote cl-block macroexp-parse-body nil cl-defun] 18 (#$ . 69533)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put cl-defsubst edebug-form-spec cl-defun function-put lisp-indent-function 2] 4)
#@51 

(fn ARGNS BODY SIMPLE WHOLE UNSAFE &rest ARGVS)
(defalias 'cl--defsubst-expand #[1413 "C\203\300\301B!\204\207\302!\203\211\303\240\210\304C\305\304\306\307\310##\"
\242\2046\202Q
\242A\204K\311\242@A\242@@\n#\202Q\312\242	\"\262\211\203]\313
	E\207\207" [cl--safe-expr-p progn cl--simple-exprs-p t nil delq cl-mapcar make-closure #[514 "\300\242\204\302
!\203\301B\301\242B\240\210\303\207

D\207" [V0 V1 macroexp-const-p nil] 5 "\n\n(fn ARGN ARGV)"] cl-subst cl--sublis let] 15 (#$ . 70530)])
#@88 Perform substitutions indicated by ALIST in TREE (non-destructively).

(fn ALIST TREE)
(defalias 'cl--sublis #[514 "\211\236\211\203\n\211A\207
:\203\300@\"\300A\"B\207
\207" [cl--sublis] 7 (#$ . 71074)])
#@13 

(fn TYPE)
(defalias 'cl--find-class '(macro . #[257 "\300
\301BB\207" [get ('cl--class)] 4 (#$ . 71293)]))
(defvar cl--struct-default-parent nil)
#@61 If non-nil, `cl-defstruct' will define inlinable functions.
(defvar cl--struct-inline t (#$ . 71447))
#@1357 Define a struct type.
This macro defines a new data type called NAME that stores data
in SLOTs.  It defines a `make-NAME' constructor, a `copy-NAME'
copier, a `NAME-p' predicate, and slot accessors named `NAME-SLOT'.
You can use the accessors to set the corresponding slots, via `setf'.

NAME is usually a symbol, but may instead take the form (NAME
OPTIONS...), where each OPTION is either a single keyword
or (KEYWORD VALUE) where KEYWORD can be one of `:conc-name',
`:constructor', `:copier', `:predicate', `:type', `:named',
`:initial-offset', `:print-function', `:noinline', or `:include'.
See Info node `(cl)Structures' for the description of the
options.

The first element in SLOTS can be a doc string.

The rest of the elements in SLOTS is a list of SLOT elements,
each of which should either be a symbol, or take the form (SNAME
SDEFAULT SOPTIONS...), where SDEFAULT is the default value of
that slot and SOPTIONS are keyword-value pairs for that slot.

Supported keywords for slots are:
- `:read-only': If this has a non-nil value, that slot cannot be set via `setf'.
- `:documentation': this is a docstring describing the slot.
- `:type': the type of the field; currently only used for documentation.

To see the documentation for a defined struct type, use
\[describe-symbol] or \[cl-describe-type].

(fn NAME &optional DOCSTRING &rest SLOTS)
(defalias 'cl-defstruct '(macro . #[385 "
:\203\n
@\202
\243\304\211\305!\306P\307\310\311\"!\304\307\310\312	\"!\307\310\313\n\"!\304\211\314 \2035\2026\315\304\307\310\316\"!\304\211\211\211	\203J\317\202K\320	\203S\317\202T\321\304@;\205c\211A\262\242\304\211\322!\204u\323\324\325\326E\"\210\327\330\331\"B\262\203_
@:\203\221@@\202\224@\211A\262\242\243
\332\267\202U
\211\203Z
\211@\203\262\305
@!\202\263\333\262\266\202~\211A\203\325\211@=\203\312\304\262\211B\262\266\202~\211\203\335\211@\262\266\202~\211\203Z
\211@\262\266\202~\211\203Z
\211@\262\266\202~\n\203
\334\335!\210\211@\262\330\336A\"\262\f\266\202~\211@\262\266\202~\211@\262\n	\337>\204Z
\334\340\"\266\202~\341\262	\266\202~\321\262\320\262\266\202~\342
@\343\"\244\262\266\202~\334\344\"\210\266\202~\204l
\204l
\n\262	\203w
\345	!\262\f\203\215
\346\347\350D\351BB\352BB\262\202\317
\204\317
\203\257
\353\f!>\204\250
\323\324\354D\"\210\355H\203\317
\341\262\204\274
\203\302
?\205\315
\346\356\310\357\"\360BBD\262\203e\353\f!>\204\345
\323\324\354D\"\210\361H\362
!	\203\377

\n=\204\377
\334\363\"\210\203$@@
\236\206\334\364
@@#
>\f\211A\262\242\240\210\202\377
\365
\366\367\236\"\"\262
\262\n	\370>\203B\367\236\202C\371\262	\353!>\204V\323\324\354D\"\210
\372H\203`\341\262	\266\202m\204m\371\262\204|\366\367\236\"\262\204\217\203\217\307\310\373\"!\262\205\364G\367\236>GZ\374\267\202\316\375\376
E\202\362\377\201@\201A\201BGE\375\201C\201DEEF\202\362\211\201EU\203\340\375\201F
E\202\362\377\201G\375\201H\201IBBEE\262
\262
\205&\f\201EV\205&
A@@\201J=\203 \f\201KU\203 \377AAAB\202&\201LB\262

\203n\201M\201N@\377=\203F\365\201O\"\202N\377\201PBB\257C\262\201Q\201R\201SD\201T\201SDFDB\262\201E\211\2032\211
A\262\242\211
A\262\242\211\201U>\203\247\304B\262\211\367=\205\235\201SDB\262\266\202+\211\236\203\266\334\201V#\210\307\310\201W#!\211A\262\242\201X\201Y\"\346\365	\205\357\201Z\n\323\201[\201\\\201S&D\201]BBEEC\201^>\203\201C\201DE\202	\201EU\203\201_\202\201H\n\201`BBC\"BB\262B\262\f\201a\201b\201c	%#\203J\201dP\202K\333P\201e\257\fB\262\f\201fG!\203\256\201g\310\201h\201i	!@$$\304\"\fB\262\f\201j@!\203\256\201j@!\204\256@\201g\310\201k\"\304\"
B\262
\211B\262\304\240\266\f\321=\203\334\201X\201l\"\204\321\201m!\201n\201o\201pBBF\fB\262\f\202\201X\201l\"\203\201q\201r\201s\334\201t\201S\nDEEE\fB\262\f\203)\356\310\201u\"\201vBB\201w\201xB\201yBBD\244\210\266
T\262\202s\266\237\262\237\262\203U\201z\201SD\201{BBB\262\203o\201|\366\304\201}!\"BDB\262\211\203
\211@\211\242
\243\211\242
\243\211\242
\243\201~!\201\201\200\201\201\"  #\206\240\201\202\211>\206\253\211\236\211\203\263\320\202\265\n\201\203\304(BBB;\203\315\202\324\310\201\204(\"\365\201\205\346\330\201\206-\"B!\205\350\201\207	BC\"BBBBB\262\266\n
A\266\202\202q\210
\203\201\210\341D\244\210\346\201\211\fD\365\237\201\212\201Q\201\213\201SD\n\201SD\201S\206=\201\202D\341=\201S%D\201SD\201S&D\201SD\257\nD\201SDE\"BB\207" [cl--optimize-safety cl--struct-inline cl--struct-default-parent cl-struct-cl-structure-class-tags nil symbol-name "-" intern format "make-%s" "copy-%s" "%s-p" macroexp-compiling-p 3 "cl-struct-%s-tags" cl-defsubst cl-defun defun cl--struct-name-p signal wrong-type-argument cl-struct-name-p name (cl-tag-slot) mapcar #[257 "\211:\203\207\211C\207" #1=[] 2 "\n\n(fn X)"] #s(hash-table size 10 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:conc-name 162 :constructor 186 :copier 226 :predicate 239 :include 252 :print-function 277 :type 286 :named 307 :noinline 315 :initial-offset 326)) "" error "Can't :include more than once" #[257 "\211:\203\207\211C\207" #1# 2 "\n\n(fn X)"] (vector list) "Invalid :type specifier: %s" t make-list (cl-skip-slot) "Structure option %s unrecognized" cl--struct-get-class progn funcall function (cl-x cl-s cl-n) (t) type-of cl-structure-class 9 princ "#S(%s" (cl-s) 7 cl-struct-slot-info ":type disagrees with :include for %s" "No slot %s in included struct %s" append delq cl-tag-slot (vector list) true 8 "cl--struct-%s-p" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 679 vector 687)) memq (type-of cl-x) and (vectorp cl-x) >= (length cl-x) aref cl-x 0 (car-safe cl-x) (consp cl-x) nth (cl-x) vectorp 1 (cl-x) (cl-x) (declare (side-effect-free error-free)) (t) (t) eval-and-compile put quote 'cl-deftype-satisfies (cl-tag-slot cl-skip-slot) "Duplicate slots named %s in %s" "%s%s" plist-get :documentation or 'wrong-type-argument list (cl-x) (nil vector) (car cl-x) (cl-x) (cl-x) internal--format-docstring-line "Access slot \"%s\" of `%s' struct CL-X." "\n" (declare (side-effect-free t)) cl-oddp macroexp-warn-and-return "Missing value for option `%S' of slot `%s' in struct %s!" last keywordp "  I'll take `%s' to be an option rather than a default value." :read-only gv-setter (val cl-x) setf (val) gv-define-expander lambda (_cl-do _cl-x) "%s is a read-only slot" " %s" (cl-s) prin1 (cl-x) (cl-s) defalias (#'copy-sequence) &key copy-sequence cl--arglist-args cl-mapcar make-closure #[514 "
\300>\203
\207\207" [V0] 4 "\n\n(fn S D)"] record &cl-defs "Constructor for objects of type `%s'." cl--safe-expr-p cl-second ((declare (side-effect-free t))) (princ ")" cl-s) defvar :autoload-end cl-struct-define] 48 (#$ . 71557)]))
(byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put cl-defstruct doc-string-elt 2 lisp-indent-function 1 put edebug-form-spec (&define [&or symbolp (gate symbolp &rest [&or symbolp (&or [":conc-name" symbolp] [":constructor" symbolp &optional cl-lambda-list] [":copier" symbolp] [":predicate" symbolp] [":include" symbolp &rest sexp] [":print-function" sexp] [":type" symbolp] [":named"] [":initial-offset" natnump])])] [&optional stringp] &rest &or symbolp (symbolp &optional def-form &rest sexp))] 6)
#@14 

(fn CLASS)
(defalias 'cl--struct-all-parents #[257 "\302
!>\2057\303
C\211
A\262\242\211B\262\304\302!	>\204'\305\306\307D\"\210\310H\"\211\262\262
\204
\237\266\202\207" [cl-struct-cl-structure-class-tags cl-struct-cl--class-tags type-of nil append signal wrong-type-argument cl--class 3] 10 (#$ . 79258)])
#@266 Pcase patterns that match cl-struct EXPVAL of type TYPE.
Elements of FIELDS can be of the form (NAME PAT) in which case the
contents of field NAME is matched against PAT, or they can be of
the form NAME which is a shorthand for (NAME NAME).

(fn TYPE &rest FIELDS)
(defalias 'cl-struct--pcase-macroexpander #[385 "\300\301\302\303\304DED\305\306\307\"\"BB\207" [and pred pcase--flip cl-typep quote mapcar make-closure #[257 "\211:\203\n\211@\202\211
:\203
A@\202
\301\302\300!\303=\203)\304\305\300\"D\2021\306\307\305\300\"EE\207" [V0 app cl-struct-sequence-type list nth cl-struct-slot-offset pcase--flip aref] 9 "\n\n(fn FIELD)"]] 8 (#$ . 79588)])
(byte-code "\300\301\302\303#\300\304\305\301#\300\207" [define-symbol-prop cl-struct--pcase-macroexpander edebug-form-spec (sexp &rest [&or (sexp pcase-PAT) sexp]) cl-struct pcase-macroexpander] 5)
#@13 

(fn TYPE)
(defalias 'cl--defstruct-predicate #[257 "\300
!\301\236\211\203\f\211A\207\302\207" [cl-struct-sequence-type ((list . consp) (vector . vectorp) (nil . recordp)) recordp] 3 (#$ . 80462)])
#@71 Extra special cases for `cl-typep' predicates.

(fn ORIG PRED1 PRED2)
(defalias 'cl--pcase-mutually-exclusive-p #[771 "

\242\301=\2058A\211\262\2058
\242\302=\2058
A\211\262\2058
\243?\2058
@\211\262\2058
\242\303=\2058
A@\242\301=\205nA\211\262\205n
\242\302=\205n
A\211\262\205n
\243?\205n
@\211\262\205n
\242\303=\205n
A@
9\203\231\2119\203\231
\304N
\304N
\205\224\211\205\224
\305!>\206\223\211\305!>?\266\202\206\342
9\205\241
\304N\211\205\265\306
!>\205\265\307!\"\262
\206\342\2119\205\302\211\304N\211\205\326\306
!>\205\326\307!\"\262
\206\342\"\207" [cl-struct-cl-structure-class-tags pcase--flip cl-typep quote cl--class cl--struct-all-parents type-of cl--defstruct-predicate] 12 (#$ . 80669)])
(advice-add 'pcase--mutually-exclusive-p :around 'cl--pcase-mutually-exclusive-p)
#@212 Return the sequence used to build STRUCT-TYPE.
STRUCT-TYPE is a symbol naming a struct type.  Return values are
either `vector', `list' or nil (and the latter indicates a
`record' struct type.

(fn STRUCT-TYPE)
(defalias 'cl-struct-sequence-type #[257 "\301
!\302
!>\204\303\304\305D\"\210\211\306H\207" [cl-struct-cl-structure-class-tags cl--struct-get-class type-of signal wrong-type-argument cl-structure-class 7] 6 (#$ . 81525)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put cl-struct-sequence-type side-effect-free t pure] 5)
#@14 

(fn ALIST)
(defalias 'cl--alist-to-plist #[257 "\300
\211\203\211@\211@B\262\211AB\262
A\266\202\202\210\211\237\207" [nil] 6 (#$ . 82091)])
#@314 Return a list of slot names of struct STRUCT-TYPE.
Each entry is a list (SLOT-NAME . OPTS), where SLOT-NAME is a
slot name symbol and OPTS is a list of slot options given to
`cl-defstruct'.  Dummy slots that represent the struct name and
slots skipped by :initial-offset may appear in the list.

(fn STRUCT-TYPE)
(defalias 'cl-struct-slot-info #[257 "\302
!\303
!>\204\304\305\306D\"\210\211\307H\303!>\204$\304\305\306D\"\210
\310H\211?\205.\311CG\312\211W\203\262
H\303
!	>\204I\304\305\313D\"\210\211\314H\303!	>\204[\304\305\313D\"\210
\315H\316\303!	>\204o\304\305\313D\"\210\317H\320=?\205\215\321\303!	>\204\211\304\305\313D\"\210\317HD\322\303!	>\204\237\304\305\313D\"\210\307H!\"BBB\262\210\211T\262
\2021\266\211\237\207" [cl-struct-cl-structure-class-tags cl-struct-cl-slot-descriptor-tags cl--struct-get-class type-of signal wrong-type-argument cl-structure-class 4 7 (cl-tag-slot) 0 cl-slot-descriptor 1 2 append 3 t :type cl--alist-to-plist] 17 (#$ . 82249)])
(byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\"\207" [function-put cl-struct-slot-info side-effect-free t pure define-error cl-struct-unknown-slot "struct has no slot"] 5)
#@298 Return the offset of slot SLOT-NAME in STRUCT-TYPE.
The returned zero-based slot index is relative to the start of
the structure data type and is adjusted for any structure name
and :initial-offset slots.  Signal error if struct STRUCT-TYPE
does not contain SLOT-NAME.

(fn STRUCT-TYPE SLOT-NAME)
(defalias 'cl-struct-slot-offset #[514 "\301
\302!\303
!>\204\304\305\306D\"\210\211\307H\262
\"\206#\304\310D\"\207" [cl-struct-cl--class-tags gethash cl--struct-get-class type-of signal wrong-type-argument cl--class 5 cl-struct-unknown-slot] 9 (#$ . 83455)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put cl-struct-slot-offset side-effect-free t pure] 5)
#@142 Return non-nil if SYM will be bound when we run the code.
Of course, we really can't know that for sure, so it's just a heuristic.

(fn SYM)
(defalias 'cl--macroexp-fboundp #[257 "\302
!\206\303 \205\211\236A\206\211	\236A\207" [byte-compile-function-environment macroexpand-all-environment fboundp macroexp-compiling-p] 3 (#$ . 84148)])
(byte-code "\300\211\203\211@\211\242
\243\301\302#\266
A\266\202\202
\207" [((array . arrayp) (atom . atom) (base-char . characterp) (bignum . bignump) (boolean . booleanp) (bool-vector . bool-vector-p) (buffer . bufferp) (character . natnump) (char-table . char-table-p) (command . commandp) (hash-table . hash-table-p) (cons . consp) (fixnum . fixnump) (float . floatp) (function . functionp) (integer . integerp) (keyword . keywordp) (list . listp) (number . numberp) (null . null) (real . numberp) (sequence . sequencep) (string . stringp) (symbol . symbolp) (vector . vectorp) (integer-or-marker . integer-or-marker-p)) put cl-deftype-satisfies] 8)
#@17 

(fn VAL TYPE)
(defalias 'cl-typep #[514 "\211:\203
\211\242
\243
\300N\203\301\302\300N\"\"\207
\303\267\202\355\211\242
\243\211\242
\243\301\"\205c\304>\204J:\203C@V\202GY\205c
\305>\203T\266\306\207
:\203_@W\207X\207\211:\203~\211\242
\243\211\204x\301\"?\207\307\310\"\207\307\310\"\207\211\204\213
\311=\207\211A\204\226\301@\"\207\211@AB\311=\203\260\301\"\205\275\301\"\207\301\"\206\275\301\"\207\211:\203\335\211\242
\243\211\204\327\312\"\205\334\266\306\207\307\310\"\207\307\310\"\207\313\"\205
\266\306\207
\314=\204\370\307\310\"\207\211:\203
\211\242
\243\211\204\n

!\207\307\310\"\207\307\310\"\207\2119\204
\307\310\"\207\211\300N\203-
\301\300N \"\207\211\315N\2039
\211\315N!\207\211\316>\203@
\207\317
!\320
\321P!\322
!\203R
\211!\207\322\320\323P!\211\262!\203c
\211!\207\322!\203m
!\207\307\324\"\207" [cl-deftype-handler cl-typep apply #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (number 31 real 31 float 31 integer 31 not 100 or 131 and 131 eql 190 member 226)) (* nil) (* nil) t error "Bad type spec: %s" and eql memql satisfies cl-deftype-satisfies (t nil) symbol-name intern "p" cl--macroexp-fboundp "-p" "Unknown type %S"] 11 (#$ . 85160)])
(byte-code "\300\301\302\303#\300\207" [function-put cl-typep compiler-macro cl-typep--inliner] 4)
#@30 

(fn INLINE--FORM VAL TYPE)
(defalias 'cl-typep--inliner #[771 "\3002I\301!\203
\202\302\303!\304!\204%
\242\305=\204%\306\300\"\2021
:\2030
A@\2021
\211:\203\256
\211\242
\243
\307N\203P\310\311\312\307N\"DE\266\202\2021
\313\267\202s
\211\242
\243\211\242
\243\314\310	\311	DE\315>\203q\316\202\212:\203\202\317\n\311@DE\202\212\320\n\311DE\321>\203\224\316\202\255:\203\245\322\311@DE\202\255\323\311DEF\266\206\2021\211:\203\330\211\242
\243\211\204\316\324\310\311DED\266\204\2021\325\326\"\266\204\2021\325\326\"\266\202\2021\211\204\357\311\314=D\266\202\2021\211A\204
\310\311@DE\266\202\2021\211@AB\314=\203!
\314\310\311DE\310\311DEE\266\204\2021\327\310\311DE\310\311DEE\266\204\2021\211:\203\\
\211\242
\243\211\204R
\314\330\311DE\316E\266\204\2021\325\326\"\266\204\2021\325\326\"\266\202\2021\314\331\311DE\316E\266\202\2021
\332=\204\202
\325\326\"\266\202\2021\211:\203\245
\211\242
\243\211\204\233
\333\305DE\266\204\2021\325\326\"\266\204\2021\325\326\"\266\202\2021\2119\204\272
\325\326\"\2021\211\307N\203\314
\310\311\307N DE\2021\211\334N\203\335
\333\305\334NDE\2021\211\335>\203\351
\311
D\2021\336
!\337
\340P!\341
!\203\333\305DE\266\202\2021\341\337\342P!\211\262!\203\333\305DE\266\202\2021\341!\203+\333\305DE\266\202\2021\325\343\"\266\202\262

=\203?\211\266\202\202H\344DC\"\266\2020\207" [inline--just-use macroexp-copyable-p make-symbol "val" macroexp-const-p function throw cl-deftype-handler cl-typep quote apply #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (number 86 real 86 float 86 integer 86 not 179 or 225 and 225 eql 310 member 357)) and (* nil) t > >= (* nil) < <= not error "Bad type spec: %s" or eql memql satisfies funcall cl-deftype-satisfies (t nil) symbol-name intern "p" cl--macroexp-fboundp "-p" "Unknown type %S" macroexp-let*] 18 (#$ . 86577)])
#@147 Verify that FORM is of type TYPE; signal an error if not.
STRING is an optional description of the desired type.

(fn FORM TYPE &optional STRING)
(defalias 'cl-check-type '(macro . #[770 "\302 \203\303W\204	\303U\205_\304!\203\202\305\306!\307\310\311\312DE\313\314\315\206B\312	\242\316=\203?	A@\202A	D\312\fDFEE\317BB
=\203U\207\320DC\"\266\202\207" [cl--optimize-speed cl--optimize-safety macroexp-compiling-p 3 macroexp-copyable-p make-symbol "temp" progn or cl-typep quote signal 'wrong-type-argument list satisfies (nil) macroexp-let*] 14 (#$ . 88565)]))
(put 'cl-check-type 'edebug-form-spec '(place cl-type-spec &optional stringp))
#@366 Verify that FORM returns non-nil; signal an error if not.
Second arg SHOW-ARGS means to include arguments of FORM in message.
Other args STRING and ARGS... are arguments to be passed to `error'.
They are not evaluated unless the assertion fails.  If STRING is
omitted, a default message listing FORM itself is used.

(fn FORM &optional SHOW-ARGS STRING &rest ARGS)
(defalias 'cl-assert '(macro . #[897 "\302 \203\303W\204	\303U\205H\205\304\305\306\307\243\"\"\310\311\312\313	D\2045\2045\205@\314B\314	BEBBE\315BB\262
\207" [cl--optimize-speed cl--optimize-safety macroexp-compiling-p 3 delq nil mapcar #[257 "\300
!?\205\211\207" [macroexp-const-p] 3 "\n\n(fn X)"] progn or cl--assertion-failed quote list (nil)] 14 (#$ . 89244)]))
(put 'cl-assert 'edebug-form-spec '(form &rest form))
#@665 Define a compiler-only macro.
This is like `defmacro', but macro expansion occurs only if the call to
FUNC is compiled (i.e., not interpreted).  Compiler macros should be used
for optimizing the way calls to FUNC are compiled; the form returned by
BODY should do the same thing as a call to the normal function called
FUNC, though possibly more efficiently.  Note that, like regular macros,
compiler macros are expanded repeatedly until no further expansions are
possible.  Unlike regular macros, BODY can decide to "punt" and leave the
original function call alone by declaring an initial `&whole foo' parameter
and then returning foo.

(fn FUNC ARGS &rest BODY)
(defalias 'cl-define-compiler-macro '(macro . #[642 "
\300
:\203
\211A\262\242
B\262
\202\211\237\205\301D\244\262\266\302\303!\304P!\305\306\307>\203;\310\307\"\202?\311BBBB\312\313D\314\315DFE\207" [nil &rest intern symbol-name "--cmacro" eval-and-compile cl-defun &whole delq _cl-whole-arg put quote 'compiler-macro function] 11 (#$ . 90068)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put cl-define-compiler-macro edebug-form-spec cl-defmacro function-put lisp-indent-function 2] 4)
#@230 Like `macroexpand', but for compiler macros.
Expands FORM repeatedly until no further expansion is possible.
Returns FORM unchanged if it has no compiler macro, or if it has a
macro that returns its `&whole' argument.

(fn FORM)
(defalias 'cl-compiler-macroexpand #[257 "\211\242\300
9\2031
\301N\211\262\2041\302!\2031
K\211\242\303=\262
\203*\304K\"\2031
K\262\202\211\205A\305\211A#\211\262=?\266\202\204\207" [nil compiler-macro fboundp autoload autoload-do-load apply] 8 (#$ . 91272)])
(defvar cl--active-block-names nil)
#@29 

(fn CL-WHOLE-ARG CL-FORM)
(defalias 'cl--block-wrapper--cmacro #[514 "\211A@A@C\211B\302\303AA!	\"
A\203#\304A@\305!BB\202$\211)\207" [cl--active-block-names macroexpand-all-environment macroexpand-all macroexp-progn catch macroexp-unprogn] 8 (#$ . 91824)])
(put 'cl--block-wrapper 'compiler-macro 'cl--block-wrapper--cmacro)
#@37 

(fn CL-WHOLE-ARG CL-TAG CL-VALUE)
(defalias 'cl--block-throw--cmacro #[771 "
A@\236\211\203
\211\301\241\210\210\302E\207" [cl--active-block-names t throw] 6 (#$ . 92165)])
(put 'cl--block-throw 'compiler-macro 'cl--block-throw--cmacro)
#@31 

(fn FORM A LIST &rest KEYS)
(defalias 'cl--compiler-macro-member #[899 "\211G\300U\205\211@\301=\205\302
A@!\211\303\267\202#\304E\207\305E\207
\203-\211\306=\2032\307E\207\207" [2 :test cl--const-expr-val #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (eq 25 equal 30)) memq member eql memql] 8 (#$ . 92414)])
#@31 

(fn FORM A LIST &rest KEYS)
(defalias 'cl--compiler-macro-assoc #[899 "\211G\300U\205\211@\301=\205\302
A@!\211\303\267\202#\304E\207\305E\207\306!\203E
\2033\211\307=\203E\310\302!!\203@\305E\207\304E\207\207" [2 :test cl--const-expr-val #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (eq 25 equal 30)) assq assoc macroexp-const-p eql floatp] 8 (#$ . 92785)])
#@31 

(fn FORM A LIST &rest KEYS)
(defalias 'cl--compiler-macro-adjoin #[899 "\300
>\203\207\301!\203\202\302\303!\301!\203\202\"\302\304!\305\306BBB\307EF
=\203=\211\266\202\202G\310DC\"\266\202
=\203N\207\310DC\"\207" [:key macroexp-copyable-p make-symbol "va" "vlist" if cl-member cons macroexp-let*] 12 (#$ . 93212)])
#@36 

(fn FORM SYM PROP &optional DEF)
(defalias 'cl--compiler-macro-get #[1027 "\211\203\f\300\301DF\207\302E\207" [cl-getf symbol-plist get] 8 (#$ . 93570)])
(byte-code "\300\211\203\211@\301
\302\303#\210
A\266\202\202
\210\304\305!\210\306\307\310\"\210\306\311\312\"\207" [(cl-first cl-second cl-third cl-fourth cl-fifth cl-sixth cl-seventh cl-eighth cl-ninth cl-tenth cl-rest cl-endp cl-plusp cl-minusp cl-caaar cl-caadr cl-cadar cl-caddr cl-cdaar cl-cdadr cl-cddar cl-cdddr cl-caaaar cl-caaadr cl-caadar cl-caaddr cl-cadaar cl-cadadr cl-caddar cl-cadddr cl-cdaaar cl-cdaadr cl-cdadar cl-cdaddr cl-cddaar cl-cddadr cl-cdddar cl-cddddr) put side-effect-free t cl-proclaim (inline cl-acons cl-map cl-notany cl-notevery cl-revappend cl-nreconc gethash) mapc #[257 "\300
\301\302#\207" [function-put side-effect-free t] 5 "\n\n(fn X)"] (cl-oddp cl-evenp cl-signum last butlast cl-ldiff cl-pairlis cl-gcd cl-lcm cl-isqrt cl-floor cl-ceiling cl-truncate cl-round cl-mod cl-rem cl-subseq cl-list-length cl-get cl-getf) #[257 "\300
\301\302#\207" [function-put side-effect-free error-free] 5 "\n\n(fn X)"] (eql cl-list* cl-subst cl-acons cl-equalp cl-random-state-p copy-tree cl-sublis)] 6)
#@134 Define NAME as a new data type.
The type name can then be used in `cl-typecase', `cl-check-type', etc.

(fn NAME ARGLIST &rest BODY)
(defalias 'cl-deftype '(macro . #[642 "\300\301\302\303D\304\305\306\307\310\nBBBBDFE\207" [cl-eval-when (compile load eval) put quote 'cl-deftype-handler cl-function lambda &cl-defs ('*)] 13 (#$ . 94771)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\300\311\312\313#\207" [put cl-deftype edebug-form-spec cl-defmacro function-put doc-string-elt 3 lisp-indent-function 2 extended-char cl-deftype-handler #[0 "\300\207" [(and character (not base-char))] 1]] 6)
#@158 Return the value of slot SLOT-NAME in INST of STRUCT-TYPE.
STRUCT and SLOT-NAME are symbols.  INST is a structure instance.

(fn STRUCT-TYPE SLOT-NAME INST)
(defalias 'cl-struct-slot-value #[771 "\300
\"\204\301\302D\"\210\303!\304=\203\305\"
8\207\211\305\"H\207" [cl-typep signal wrong-type-argument cl-struct-sequence-type list cl-struct-slot-offset] 7 (#$ . 95401)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put cl-struct-slot-value compiler-macro cl-struct-slot-value--inliner side-effect-free t] 5)
#@48 

(fn INLINE--FORM STRUCT-TYPE SLOT-NAME INST)
(defalias 'cl-struct-slot-value--inliner #[1028 "\3002\241\301!\203\202\302\303!\301!\203\202\302\304!\301!\203(\202+\302\305!\306\307\310E\311\312\313D\314EEE\315\316\317D\312\314DE\320\321EE\322\321\n\nEEFE
=\203j\211\266\202\202t\323DC\"\266\202
=\203\200\211\266\202\202\212\323DC\"\266\202
=\203\226\211\266\202\202\240\323DC\"\266\2020\207" [inline--just-use macroexp-copyable-p make-symbol "struct-type" "slot-name" "inst" progn unless cl-typep signal quote wrong-type-argument list if eq cl-struct-sequence-type nth cl-struct-slot-offset aref macroexp-let*] 17 (#$ . 95949)])
(byte-code "\300\301\302\303#\210\304\301!\207" [make-obsolete-variable cl-macs-load-hook "use `with-eval-after-load' instead." "28.1" run-hooks] 4)
#@120 Pcase pattern that matches objects of TYPE.
TYPE is a type descriptor as accepted by `cl-typep', which see.

(fn TYPE)
(defalias 'cl-type--pcase-macroexpander #[257 "\300\301\302\303DED\207" [pred pcase--flip cl-typep quote] 6 (#$ . 96793)])
(byte-code "\300\301\302\303#\300\304\305\301#\306\307!\207" [define-symbol-prop cl-type--pcase-macroexpander edebug-form-spec nil cl-type pcase-macroexpander provide cl-macs] 5)