;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:08:59 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/cl-macs.el
;;; in Emacs version 24.3.1
;;; with all optimizations.
;;; Function definitions are lazy-loaded.

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

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

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


(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require cl-lib macroexp gv] 2)
(defalias 'cl-pop2 '(macro . #[257 #@67 ("\300\301\302DD\303\302\211DDEE\207" . [prog1 car cdr setq])(#$ . 723) nil 8 "\n\n(fn PLACE)"]))
(put 'cl-pop2 'edebug-form-spec 'edebug-sexps)
(defalias 'cl--compiler-macro-list* #[642 #@80 ("\300B!\211@

A\211\262\203
0\301@E\262

\202
0\207" . [reverse cons])(#$ . 920) nil 8 "\n\n(fn FORM ARG &rest OTHERS)"])
(defalias 'cl--compiler-macro-cXXr #[514 #@331 ("

@\300@!\211G\301Z\302\303\"\204/
0\304!\203)
0K9\203)
0\305KAB\"\202O
0\306\307!\202O
0\211\310\224V\203N
0



H\311=\203B
0\312\202C
0\313D\262\211S\262

\202/
0\207" . [symbol-name 2 string-match "c[ad]+r\\'" fboundp cl--compiler-macro-cXXr error "Compiler macro for cXXr applied to non-cXXr form" 0 97 car cdr])(#$ . 1098) nil 8 "\n\n(fn FORM X)"])
(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 #@294 ("\211\204
0\301\262



:\203K
0

@\302>\204K
0

@9\205S
0

@>\204'
0

@\303N\205S
0\211S\262



A\211\262\203>
0\304@\"\211\262\204+
0

?\205J
0\211\305Y\205J
0\211\207\211\305V\205S
0\211S\207" . [cl--simple-funcs 10 (quote function cl-function) side-effect-free cl--simple-expr-p 0])(#$ . 1785) nil 5 (#$ . 1672)])
(defalias 'cl--simple-exprs-p #[257 #@82 ("\211\203
0\300

@!\203
0\211A\262

\202
0
0\211?\207" . [cl--simple-expr-p])(#$ . 2151) nil 3 "\n\n(fn XS)"])
#@35 Check if no side effects.

(fn X)
(defalias 'cl--safe-expr-p #[257 #@239 ("\211:\205\n
0\211@\302>??\206:
0\211@9\205:
0\211@>\204)
0\211@	>\204)
0\211@\303N\205:
0\211A\211\262\2038
0\304

@!\204)
0\211?\207" . [cl--simple-funcs cl--safe-funcs (quote function cl-function) side-effect-free cl--safe-expr-p])(#$ . 2345) nil 3 (#$ . 2271)])
(defalias 'cl--const-expr-p #[257 #@186 ("\211:\203%
0\211@\300=\2063
0\211@\301>\205$
0\211A@9\206$
0\211A@\242\302=\205$
0\303\207\2119\2032
0\211\304>\2053
0\305\207\305\207" . [quote #'cl-function lambda func (nil t) t])(#$ . 2655) nil 3 "\n\n(fn X)"])
(defalias 'cl--const-expr-val #[257 #@71 ("\300

!\205
0\211:\203
0\211A@\207\211\207" . [macroexp-const-p])(#$ . 2914) nil 3 "\n\n(fn X)"])
#@73 Count number of times X refers to Y.  Return nil for 0 times.

(fn X Y)
(defalias 'cl--expr-contains #[514 #@239 ("\211\232\203
0\300\207

:\203B
0

@\301>\204B
0\302:\203.
0\211\303\211A\262@\"\206(
0\302\\\262

\202
0\211\303\"\2067
0\302\\\262

\211\302V\205A
0\211\207\304\207" . [1 (quote function cl-function) 0 cl--expr-contains nil])(#$ . 3136) nil 7 (#$ . 3022)])
(defalias 'cl--expr-contains-any #[514 #@84 ("\211\203
0\300@\"\204
0\211

A\262@\210\202
0
0\207" . [cl--expr-contains])(#$ . 3450) nil 5 "\n\n(fn X Y)"])
#@66 Check whether X may depend on any of the symbols in Y.

(fn X Y)
(defalias 'cl--expr-depends-p #[514 #@105 ("\300!?\205
0\301!?\206
0\302\"\207" . [macroexp-const-p cl--safe-expr-p cl--expr-contains-any])(#$ . 3681) nil 5 (#$ . 3573)])
#@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 #@136 ("\211;\203	
0\211\202\n
0\301

\250\203
0

\202
0\211T\302\303\304#!\207" . [cl--gensym-counter "G" make-symbol format "%s%d"])(#$ . 3977) nil 8 (#$ . 3823)])
#@138 Generate a new interned symbol with a unique name.
The name is made by appending a number to PREFIX, default "G".

(fn &optional PREFIX)
(defalias 'cl-gentemp #[256 #@155 ("\211;\203	
0\211\202\n
0\301\302\303\304\305#\211\262!\203
0T\202
0\306

!\207" . [cl--gensym-counter "G" nil intern-soft format "%s%d" intern])(#$ . 4322) nil 8 (#$ . 4150)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\207" [put cl-declarations edebug-form-spec (&rest ("cl-declare" &rest sexp)) cl-declarations-or-string (&or stringp cl-declarations) cl-lambda-list (([&rest arg] [&optional ["&optional" cl-&optional-arg &rest cl-&optional-arg]] [&optional ["&rest" arg]] [&optional ["&key" [cl-&key-arg &rest cl-&key-arg] &optional "&allow-other-keys"]] [&optional ["&aux" &rest &or (symbolp &optional def-form) symbolp]])) cl-&optional-arg (&or (arg &optional def-form arg) arg) cl-&key-arg (&or ([&or (symbolp arg) arg] &optional def-form arg) arg)] 4)
(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 #@1442 ("

@A

\306\211\306\211\306\211\306@;\204!
0@\242\307>\203.
0\211A\262@B\262\202
0<\2039
0\310!\202<
0\311D\262\312!\211A\203M
0\211\311AD\241\210\210\313>\211/A@)\211\203n
0\314\313\314	\"\"\262	\211/A@)\315>\211\203}
0\314\315\"\262\316>\203\207
0\317\320!\210\321>\211/\211A@)\322\203\247
0\314@\314\"\"\323DD\244\262\266\203\335
0@9\203\335
0@\324>\204\335
0@\325=\203\320
0	\204\335
0\211/A@):\204\335
0\211A\262@

B\262

\202\251
0\326=\204\353
0\327BBC\262\204\374
0\306

\237\237\244BB\202w

\325

>\203

\325B\262\330\306G\325>\203

\331\202

\332Z#\210\f\237\205'

\333\334\237BB

\237\311\f\211A@@D\244\237\335 \336\337\332\340\341\342!\343\"\344\345%DC\216\346\347!\210\350@;\205X

\211A\262@\351\352\353\354\f!B\"\")B\262

\262

\355\f\356
\237\n\"BBC\244BB.\207" . [cl--bind-block cl--bind-defs cl--bind-enquote cl--bind-inits cl--bind-lets cl--bind-forms nil (interactive declare cl-declare) cl-copy-list &rest last &cl-defs delq &cl-quote &whole error "&whole not currently implemented" &environment macroexpand-all-environment &aux (nil &rest &body &key &aux) &optional cl-none cl-block cl--do-arglist 1 0 cl-eval-when (compile load eval) match-data funcall make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 "\n\n(fn)" require help-fns help-add-fundoc-usage format "%S" fn cl--make-usage-args let* append x])(#$ . 5590) nil 19 (#$ . 5275)])
#@198 Define NAME as a function.
Like normal `defun', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (cl-block NAME ...).

(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defun '(macro . #[642 #@95 ("\300B\"\301ABB

@\203
0\302@E\202
0\211\207" . [cl--transform-lambda defun progn])(#$ . 7309) nil 8 (#$ . 7070)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\314\302\315#\207" [put cl-defun edebug-form-spec (&define [&or name ("setf" :name setf name)] cl-lambda-list cl-declarations-or-string [&optional ("interactive" interactive)] def-body) doc-string-elt 3 lisp-indent-function 2 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 (symbolp &optional def-form) symbolp]] [&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 (symbolp &optional def-form) symbolp]] . [&or arg nil]))] 4)
#@198 Define NAME as a macro.
Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
and BODY is implicitly surrounded by (cl-block NAME ...).

(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defmacro '(macro . #[642 #@98 ("\300B\"\301ABB

@\203
0\302@E\202
0\211\207" . [cl--transform-lambda defmacro progn])(#$ . 8935) nil 8 (#$ . 8693)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\307#\210\300\310\302\311#\210\300\312\302\313#\207" [put cl-defmacro edebug-form-spec (&define name cl-macro-list cl-declarations-or-string def-body) doc-string-elt 3 lisp-indent-function 2 cl-lambda-expr (&define ("lambda" cl-lambda-list def-body)) function-form (&or ([&or "quote" "function"] &or symbolp lambda-expr) ("cl-function" cl-function) form)] 4)
#@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 #@151 ("\211\242\300=\203!
0\301

A\302\"\303\300ABD

@\203
_
0\304@E\202 
0\211\207\303

D\207" . [lambda cl--transform-lambda cl-none function progn])(#$ . 9696) nil 6 (#$ . 9496)]))
(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 #@113 ("\2119\203\f
0\300\301!\226!\207\211:\203
0\302

!\207\207" . [make-symbol symbol-name cl--make-usage-args])(#$ . 10051) nil 4 (#$ . 9951)])
(defalias 'cl--make-usage-args #[257 #@743 ("\301

!\243\203,
0\301

!\211A\302\303\304\305\306\307\"\310\"\311\312%DC\216

\313\241\210\314!\315!\244)\207\316

>\211\203B
0\317

@\320\211A@)\"\"\262\210\313C\321\303\322\323\306\307!\324\"\325\326%\"\207" . [x last funcall make-byte-code 0 "\300\301\241\207" vconcat vector [] 2 "\n\n(fn)" nil cl--make-usage-args cl--make-usage-var &cl-defs delq remq mapcar 257 "\2119\203,
0\302

!\303H\211\304=\203
0\300\240\202+
0\305

\306=\203&
0\302!\307\310O\202)
0\302!\226!\207\211:\2042
0\207\300@\311>\203=
0\312

!\207\211@:\203Z
0\300@\313=\203Z
0\211\211@@)\314@A@!D\202^
0\314

@!

A@\312AA!BB\207" [x 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)"])(#$ . 10239) nil 12 "\n\n(fn ARGLIST)"])
(defalias 'cl--do-arglist #[770 #@2942 ("<\204
0>\204
09\204
0\306\307\"\207D	B\211\207\310!\262\311!\211A\2031
0\211\312AD\241\210\210\313>\211\203=
0\211\312\240\210\210\314>\203H
0\306\315!\210\312>\316 \203U
0\n\202V
0\317\320\211\211\211\204b
0\321\262\211A@)<\203t
0\322\323!\262\202|
0\211A@)\262	D	B	@\324=\203\233
0	A@\nAA\262D	B	\262\211\203\277
0\211@>\204\277
0\211=\204\270
0\325D\262\211A\262

\202\241
0\211@\326>\203\333
0\327\330D\331
\"GE\262\n

=?\262\210	\2037

	@>\2047

	A\204\363
0

\204\367
0\332\202\370
0\333D\334\211A\262
@\204

\321U\203

\202)

\335\336\337\340\f\341=?\205\"

\342\fD\330DEEF\"\266T\262\343\262\202\334
0	@\344=\203\301

	\211A\262@\203\301

	\2037

	@>\2047

	\211A\262@\211:\204f

\211C\262

\211\211AA)\203{

\334\3458\346	\347BB\"\210\211A\203\206

\211A@\202\221


@\206\221

\211@
\236A@\332D

\203\243

@\203\243

\342D\262\334@\203\264

\335F\202\265

\"\210\nT\262\266\202I

	@\312=\203\342

	A@\nAA\262\211:\203\336

\334

\"\210\210\202	@\350=\204\321U\204

\204\335\336\351\340\f\341=?\205\342\fD\352\330DEEEEABA	@\350=\203	\211A\262@\203	\203	@>\204	\211A\262@\211:\204C\211C\262

\211@:\203R\211\211@@)\202l\353

@!\211\321H\354=\203d\211\355\320O\262

\356\357\360\"!\262



@:\203y

@A@\202{

@A\203\211\211A@)\202\226
@\206\226\211
\236\211A@)\361\342DE

\203\253@\203\253\342D\262\211AA)\203\335\3458\206\275\322\362!\333\325DD\334\"\210\334\335\363\364\365BBEF\"\266\202	\334\333\325\204\351\202\366\367!\343=\203\377\342\320\370\n!DD\202\340\320	EEDD\"\210	B\262	\266\202&\237\262	@\371=\203*	\211A\262@\204\211\203\211\321U\204\211\322\372!\373\374\375\361\333D\342\376\f\"DE\364\325\211	DDED\333\325\361\342BEDD\364\377BBD\343\306\357\201B
0\"\333\nDEDFE\201C
0\nDCEABA\266	@\201D
0=\203
0	\211A\262@\203
0	\203\211	@>\204\211	@:\203\362@\203\331	@A@\203\331\334\n\211@@)\342\f\211A\262@\211A@)D\"\210\202\235\334\n\211@@)\211A\262
@\211A@)\"\210\202\235\334\n\211A\262\f@\320\"\210\202\235	\205\f\306\201E
0\"\207" . [cl--lambda-list-keywords cl--bind-lets cl-optimize-safety x cl--bind-block cl--bind-defs error "Invalid argument name: %s" cl-copy-list last &rest &body &environment "&environment used incorrectly" cl--compiling-file 3 nil 0 make-symbol "--cl-rest--" &whole cdr (nil &aux) = length cl-ldiff pop car cl--do-arglist if signal 'wrong-number-of-arguments list cl-none quote t &optional 2 and (t) &key 'wrong-number-of-arguments + symbol-name 95 1 intern format ":%s" memq "--cl-var--" prog1 setq (t) or cl--const-expr-p cl--const-expr-val &allow-other-keys "--cl-keys--" (:allow-other-keys) while cond append (nil) cl--bind-enquote cl--bind-forms "Keyword argument %%s not one of %s" let &aux "Malformed argument list %s"])(#$ . 11061) nil 27 "\n\n(fn ARGS EXPR &optional NUM)"])
(defalias 'cl--arglist-args #[257 #@330 ("\211<\204
0\211C\207\302\211\211:\203c
0\211A\262@\262

\211>\203$
0\211\262\202
0\211\303=\2034
0\211A\262@\210\202
0\211:\203A
0

\203A
0\211@\262

\211:\203Y
0\211A\203Y
0

\304=\203Y
0\211\211A@)\262

\305!\244\262\202
0\205j
0C\244\207" . [cl--lambda-list-keywords x nil &cl-defs &key cl--arglist-args])(#$ . 14099) nil 7 "\n\n(fn ARGS)"])
#@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 #@249 ("\306\211\306\211\307\306\310\206
0\311\"\210\312\313\n\314\237\312	\237\"BBC#.\207" . [cl--bind-lets cl--bind-forms cl--bind-inits cl--bind-defs cl--bind-block cl--bind-enquote nil cl-none cl--do-arglist (&aux) append (progn) let*])(#$ . 14620) nil 12 (#$ . 14470)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-destructuring-bind lisp-indent-function 2 edebug-form-spec (&define cl-macro-list def-form cl-declarations def-body)] 4)
(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 #@406 ("\301\302!\203P
0\302 \203P
0\204P
0\303\304!\204P
0\305>\206
0\306>\307\310>\204,
0\311>\203C
0\211\2039
0\312\313\314\"B\202N
0\315\316\211BBB\202N
0\211\203M
0\317\312B!\210\316)\207\317>\204\\
0\320>\205_
0\312

B\207" . [cl-not-toplevel fboundp cl--compiling-file boundp for-effect compile :compile-toplevel t load :load-toplevel progn mapcar cl--compile-time-too if nil eval :execute])(#$ . 15453) nil 7 (#$ . 15124)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-eval-when lisp-indent-function 1 edebug-form-spec ((&rest &or "compile" "load" "eval") body)] 4)
(defalias 'cl--compile-time-too #[257 #@357 ("\211\2429\203

0\211\242\302N\204
0\303

\304B\"\262

\211\242\305=\203$
0\305\306\307A\"B\207\211\242\310=\203K
0\211A@\311

>\204:
0\312

>\203I
0\310\313B\211AA)BB\202J
0

\207\311

!\210\207" . [byte-compile-macro-environment x byte-hunk-handler macroexpand (cl-eval-when) progn mapcar cl--compile-time-too cl-eval-when eval :execute compile])(#$ . 16098) nil 6 "\n\n(fn FORM)"])
#@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 #@473 ("\300 \203F
0\301\302!\303\304DE\305\306!\203:
0\307\310!\203:
0\307\311!\203:
0\312\313\314\315\316\304\312KDE\312\304DD\317BBBBM\210\202@
0\320

\321J\"\210\322\304DD\207\304\323!D\207" . [cl--compiling-file cl-gentemp "--cl-load-time--" set quote fboundp byte-compile-file-form-defmumble boundp this-kind that-one byte-compile-file-form lambda (form) fset 'byte-compile-file-form ((byte-compile-file-form form)) print byte-compile--outbuffer symbol-value eval])(#$ . 16701) nil 11 (#$ . 16497)]))
(put 'cl-load-time-value 'edebug-form-spec '(form &optional sexp))
#@472 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, cl-case returns nil.  A single 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 #@629 ("\300\301\"\203
0

\202
0\302\303!\304C\305\306\307\310\311\312\313\"\314\"\315\316%\"B=\203.
0\211\2026
0\317DCE\207" . [cl--simple-expr-p 3 make-symbol "--cl-var--" nil cond mapcar make-byte-code 257 "\211@\302>\203
0\303\202U
0\211@\304=\203
_
0\305\306\300\307\310\301@!DF\202U
0\211@<\2038
0\301\311@\301@\"\240\210\312\300\307@DE\202U
0\211@\301@>\203F
0\305\313@\"\210\301

@\301@B\240\210\314\300\307@DE

A\206[
0\315B\207" vconcat vector [(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)" let])(#$ . 17795) nil 13 (#$ . 17282)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-case lisp-indent-function 1 edebug-form-spec (form &rest (sexp body))] 4)
#@113 Like `cl-case', but error if no case fits.
`otherwise'-clauses are not allowed.

(fn EXPR (KEYLIST BODY...)...)
(defalias 'cl-ecase '(macro . #[385 #@72 ("\300\301\302\"BB\207" . [cl-case append ((cl--ecase-error-flag))])(#$ . 18757) nil 7 (#$ . 18603)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-ecase lisp-indent-function 1 edebug-form-spec cl-case] 4)
#@351 Evals EXPR, chooses 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,
cl-typecase 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 #@500 ("\300\301\"\203
0

\202
0\302\303!\304C\305\306\307\310\311\312\313\"\314\"\315\316%\"B=\203.
0\211\2026
0\317DCE\207" . [cl--simple-expr-p 3 make-symbol "--cl-var--" nil cond mapcar make-byte-code 257 "\211@\302=\203
0\303\202,
0\211@\304=\203
_
0\305\306\300\307\310\301@!DF\202,
0\301

@\301@B\240\210\311\300@\"

A\2062
0\312B\207" vconcat vector [otherwise t cl--ecase-error-flag error "cl-etypecase failed: %s, %s" quote reverse cl--make-type-test (nil)] 7 "\n\n(fn C)" let])(#$ . 19387) nil 13 (#$ . 18991)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-typecase lisp-indent-function 1 edebug-form-spec (form &rest ([&or cl-type-spec "otherwise"] body))] 4)
#@114 Like `cl-typecase', but error if no case fits.
`otherwise'-clauses are not allowed.

(fn EXPR (TYPE BODY...)...)
(defalias 'cl-etypecase '(macro . #[385 #@76 ("\300\301\302\"BB\207" . [cl-typecase append ((cl--ecase-error-flag))])(#$ . 20255) nil 7 (#$ . 20096)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-etypecase lisp-indent-function 1 edebug-form-spec cl-typecase] 4)
#@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 #@162 ("\300\301B!\203\f
0\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--"])(#$ . 21072) nil 9 (#$ . 20501)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-block lisp-indent-function 1 edebug-form-spec (symbolp body)] 4)
#@110 Return from the block named nil.
This is equivalent to `(cl-return-from nil RESULT)'.

(fn &optional RESULT)
(defalias 'cl-return '(macro . #[256 #@43 ("\300\301E\207" . [cl-return-from nil])(#$ . 21555) nil 4 (#$ . 21403)]))
(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 #@96 ("\300\301\302\"!\303\304DE\207" . [intern format "--cl-block-%s--" cl--block-throw quote])(#$ . 22065) nil 6 (#$ . 21691)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-return-from lisp-indent-function 1 edebug-form-spec (symbolp &optional form)] 4)
#@723 The Common Lisp `loop' macro.
Valid clauses are:
  for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
  for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
  for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
  always COND, never COND, thereis COND, collect EXPR into VAR,
  append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
  count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
  if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
  unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
  do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
  finally return EXPR, named NAME.

(fn CLAUSE...)
(defalias 'cl-loop '(macro . #[128 #@1324 ("\306\307\310\311\312\311\306\313!\"\"\">\204
0\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]
0\321 \210\202O
0#\203l
0#\322BC)B)\n\203\203
0\n\323BC)B)\324\n\325BB'B'\f\237%\206\214
0&C\244\326(\237!\211,\211A@)'\237\244\316
\237\203\305
0\314\327\330@\306=\203\264
0\202\276
0\331@\332BBB\333#E\202\313
0\315@BBC#\203\353
0\334\232\203\335
0$C\202\354
0\335#\336B$FC\202\354
0#$\203\372
0$C)B))\203F

)\211,@A)\203

\337)\211A)@\306#C\262

\202\372
0\312)\203;

)\211,@A)\204;

)\211A)@@

B\262

\202

\337

\312#C\266\202\202\372
0\203R

\340BBC\262

\314*BB\266\204.\207" . [cl--loop-symbol-macs cl--loop-destr-temps cl--loop-first-flag cl--loop-map-form 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-- cl-subst or ((cl-return-from --cl-finish-- nil)) --cl-map (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 x])(#$ . 23111) nil 19 (#$ . 22346)]))
(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" "unless" "return"] form] symbolp form))
(defalias 'cl-parse-loop-clause #[0 #@9449 ("\211A@\306\307\204
0\310\311!\210\202\240\f\312=\203!
0\211A@\202\240\f\313=\203N
0@\314>\2033
0\210A@:\204=
0\310\315!\210@:\203\240\f\211A@\nB\202=
0\316=\203\257
0@\317=\203j
0A@AA\206f
0\320\202\240\f@\321>\203v
0\210A@:\204\200
0\310\322!\210\211@@)\317=\203\236
0	\204\236
0\211A@A@\206\232
0\323\202\240\f@:\203\240\f\211A@
B\202\236
0\324>\2036\325\211\211\211\211A@\206\304
0\326\327!\211A@\262\330=\203\331
0\211A@\262\331>\203\347
0\211A@\262\332>\203\365
0\333\262\334B\335>\203\353

B\211@\336>\203\f

\310\337!\210@\340=\206

AA@\341>@\342>\206&

AA@\343>@\344>\2054

A@AA@\345>\205B

A@AA@\346=\205P

A@AA\347!?\205Z

\350\327!\347!?\205d

\350\327!\203x

\247\203x

\351X\203x

\310\352\"\210\206

\351D\fB\262\f

\203\221



D\fB\262\f\211\203\235

\211D\fB\262\f\203\310

\203\262

\203\256

\353\202\273

\354\202\273

\203\272

\355\202\273

\356\206\302

E@B@\203\323

\357\202\324

\360	\206\337

\206\337

\361ED\nB\262\n\266\202\300\362>\203\211\363=\211\203

9\203

\202\350\327!\211\211A@DB\262\364

D@B@	\365=\203.\366DDABA\202N\211=\204N\325DB\262\203E

\202H\366DDB\262\211@\346=\203|A@AA\211\242\367>\203s\211A@9\203s\211A@D\202w\370

E\262

\202\371DDB\262\266\202\300\372=\203
0\211A@@\373=\203\246A@AA\202\247\211\325DB\262\204\272@\374=\203\333\375B\206\307\350\327!\211BFDB\262

DB\262\202\373=\203\346\202\365\375B\206\362\350\327!\211BFDB\262\266\202\300\376>\203n\350\377!\350\201J
0!

\211A@DB\262\211\201K
0DB\262\355\201L
0\201M
0DE\201N
0DE@B@	\201O
0=\203T\201P
0EDABA\202i\325DB\262\201P
0EDB\262\266\202\300\201Q
0>\203b@\201R
0>\206\217@\201S
0>?\205\217\310\201T
0!A@AA\350\201U
0!@\201V
0=\203\324\211A@)G\201W
0U\203\314A@@\201X
0=\203\314A@AA\211A@)\202\331\310\201Y
0!\202\331\350\201J
0!

D	B\262	\211\351D	B\262	\203\350\201Z
0!\211\201N
0DD\nB\262\n\201[
0EDABA\355E@B@\210\202Q\325D	B\262	\374\201\\
0\364D\355\201N
0DEEE@B@\375\364D\201]
0D\201P
0EFDB\262\211\201M
0DDB\262\266\202\300>\203\353@\201^
0>\204y\310\201T
0!\210A@AA\211@\201V
0=\203\302\211A@)G\201W
0U\203\272A@@>\203\272A@@	=\204\272A@AA\211A@)\202\305\310\201Y
0!\202\305\350\327!	\201_
0>\203\324\211\262\262\201`
0\201a
0D\201b
0BBEC\266\202\300\201c
0>\203@\201d
0>\205A@AA\201e
0\201a
0C\201b
0BBEC\210\202\300\201f
0>\203\200\325\211\211@\201g
0>\203d@\201h
0=\203CA@AA\262\202%@\201i
0=\203XA@AA\262

\202%A@AA\262\202%\201j
0\201a
0\350\327!D\201k
0BB\257C\266\202\300\201l
0>\2039\325\211\211\211\350\201m
0!\350\201n
0!@\201o
0>\203\353@\201h
0=\203\265A@AA\262\202\227@\201i
0=\203\312A@AA\262\202\227@\201p
0=\203\337A@AA\262\202\227A@AA\262\202\227:\203\f@9\203\fA9\203\f@\262A\262

\202\201q
0ED\nB\262\n\201r
0\201a
0D\201b
0BB\257C\266\202\300>\203\321@\201s
0>\204P\310\201T
0!\210A@AA\211@\201V
0=\203\231\211A@)G\201W
0U\203\221A@@>\203\221A@@	=\204\221A@AA\211A@)\202\234\310\201Y
0!\202\234\350\327!	\201t
0>\203\253\211\262\262	\201u
0>\203\272\201v
0\202\275\201w
0\201a
0D\201b
0BBEC\266\202\300\201x
0>\203\350\327!

\201y
0DB\262\211\325DB\262\201z
0\201{
0\201|
0ED\201\\
0\201L
0EEE@B@

\201}
0DDB\262\210\202\300\201~
0>\203\240@\201
0>\2056A@AA\350\327!\350\201\200
0!\203K\201\201
0D\202N\201\202
0DB\262\211\201\203
0\201\204
0DDDB\262

\325DB\262\201z
0\201{
0\201|
0ED\201\\
0\201L
0	EEE@B@\201\205
0EDB\262\266\202\3009\205\254\201\206
0N\211\203\267\211!\210\202\277\310\201\207
0\n\"\210\210@\374=\262

\203\327\201\210
0\262

\211A@\210\202\271
0\211\203\351\203\351\237DBD\202\366\201\211
0\201\212
0\"D\244D\203\201\213
0\201\214
0\237\201L
0#\201\215
0BB@B@

\2031\211\203
_\201\216
0\202\"\201L
0\201\217
0\201\220
0\237\"BEBE\266\202\240\f\201\221
0=\203g\350\327!\211\211A@DCDBD\354\201L
0\201\222
0DE\201\223
0BB@B@\210\202\240\f\201\224
0>\203\273\211A@\201\225
0\325\201\226
0\"\211F=\203\231\201\213
0\201\227
0E\201\230
0BB@B@\202\266\201\213
0\201L
0\201\231
0\201\212
0DEE\201\232
0BB@B@\266\202\240\f\201\233
0>\203!	\211A@\201\225
0\325\201\226
0\"\201\213
0\201L
0\211F=\203\373\201\231
0\201\234
0>\203\360\201\226
0\202\363\201\235
0DE\202	\201\236
0>\203\n	\201\231
0\202
	\201\220
0EE\201\237
0BB@B@\266\202\240\f\201\240
0>\203P	\211A@\201\225
0\201\241
0!\201\213
0\201\242
0\201\243
0F\201\244
0BB@B@\266\202\240\f\201\245
0>\203	\211A@\201\225
0\201\246
0!\201\213
0\201\242
0\201\247
0F\201\250
0BB@B@\266\202\240\f\201\251
0>\203\251	\211A@\201\225
0\351!\201\213
0\201\252
0E\201\253
0BB@B@\266\202\240\f\201\254
0>\203\325	\211A@\201\225
0\351!\201\213
0\375\201\252
0DE\201\255
0BB@B@\266\202\240\f\201\256
0>\203<\n\211A@\201\257
0

!\203\356	\211\202\361	\350\327!\201\225
0\325!\201\260
0\201\261
0!\351\201\262
0O!\201L
0\375EFE\201\213
0=\203#\n

\202-\n\201\263
0DCE\201\264
0BB@B@\266\202\240\f\201\265
0=\203x\n\325\211A@@\372=\205X\nA@AAD

B\262

@\374=\203m\n\211A@\210\202E\n\211\237DBD\210\202\240\f\201\266
0=\203\215\n\211A@@B@\202\240\f\201\267
0=\203\246\n\201{
0\211A@D@B@\202\240\f\201\270
0=\203\322\nG\204\272\n\350\201\271
0!G\201L
0G\211A@E@B@\201\210
0H\202\240\f\201\272
0=\203G\204\346\n\350\201\271
0!G\201L
0G\201{
0\211A@DE@B@\201\210
0H\202\240\f\201\273
0=\203=G\204\350\201\271
0!GI\204 \350\327!I\201L
0G\201{
0\201L
0I\211A@EDE@B@\202\240\f\201\274
0>\203\f\211A@\325@\201\275
0 \210\201\276
0@\237!)\325@@\201\277
0=\203p\210A\201\275
0 \210\201\276
0@\237!)

@\201\210
0=\205\207\211@\201\210
0=@\201\300
0=\203\225\210A\201\301
0=\203\244

\262\262\211\203\262\201\213
0A@B\202\267\201W
08

\203\301A@\202\307\201W
08CB\201\302
0

\201\303
0\"\203\366\350\327!\211CDBD\375\201L
0E\201\304
0\201\303
0#BB\266\202\202\375\375BB\262



\203
\f\201\213
0

\201\305
0BB\202\f\211@B@\266\202\240\f\201\306
0>\203R\f\325@:\204-\f\310\201\307
0!\210@:\203?\f\211A@

B\262

\202-\f\201\213
0\201\210
0B\237B@B@\210\202\240\f\317=\203\207\fG\204b\f\350\327!GI\204l\f\350\327!I\201L
0I\211A@G\201\310
0BBBB@B@\202\240\f9\205\221\f\201\311
0N\211\204\234\f\310\201\312
0\"\210\211 \266@\374=\205\260\f\210A\201\275
0 \207" . [cl--loop-args cl--loop-name cl--loop-initially cl--loop-result-explicit x cl--loop-finally (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 (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 (across across-ref) "--cl-vec--" cl--loop-body cl--loop-symbol-macs cl--loop-first-flag cl--loop-map-form cl--loop-bindings cl--loop-steps cl--loop-accum-var cl--loop-finish-flag cl--loop-result cl--loop-result-var "--cl-idx--" -1 setq 1+ length across-ref aref (element elements) (in-ref of-ref) (in of) "Expected `of'" "--cl-seq--" using 2 index "Bad `using' clause" "--cl-len--" elt or pop (in of) (hash-value hash-values) maphash lambda --cl-map (symbol present-symbol external-symbol symbols present-symbols external-symbols) (in of) mapatoms (overlay overlays extent extents) (in of from to) from to cl--map-overlays ((progn . --cl-map) nil) (interval intervals) "--cl-var1--" "--cl-var2--" (in of property from to) property cons cl--map-intervals (in of) (key-binding key-bindings) (key-seq key-seqs) cl--map-keymap-recursively map-keymap (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) cl--simple-expr-p intern symbol-name 3 let (t) with while until always "--cl-flag--" never thereis (if when unless) cl-parse-loop-clause cl--loop-build-ands else end unless cl--expr-contains it cl-subst (t) (do doing) "Syntax error on `do' clause" (nil) cl-loop-handler "Expected a cl-loop keyword, found %s"])(#$ . 24852) nil 21 "\n\n(fn)"])
(defalias 'cl--loop-let #[771 #@744 ("\302\211\203
0@\2429\204
0@A@\204
0A\262\202
0\203U
0\203U
0\302\262\262\203U
0\303@A@!\204N
0\304\305!\211@A@DB\262\211@A)

\240\266A\262\202*
0\203\326
0@:\203\311
0\211@@)<\203\311
0\211@@)\302\211A\262	@\211A@)	\236\206\223
0\306\307\"\206\215
0\304\305!B	B\211@A\211DB\262:\203\275
0\211A\262@\205\265
0\203\262
0\310\202\263
0\311DDB\262\202\233
0\237\n\244\262\n\266\202U
0\211A\262@

B\262

\202U
0\312=\203\375
0\203\344
0\313\202\345
0\312\314\315\237\"B\203\367
0\316\237E\202\370
0\211\262

\202

\203

\317\202

\316\237\237\244BB\207" . [x cl--loop-destr-temps nil macroexp-const-p make-symbol "--cl-var--" last 0 pop car setq cl-psetq apply nconc let* let])(#$ . 34369) nil 14 "\n\n(fn SPECS BODY PAR)"])
(defalias 'cl--loop-handle-accum #[513 #@248 ("@\305=\203!
0A@AA\211	>\204
_
0\211DC\nB\211	B\211\207\206=
0\306\307!\211DC\nB\211\203:
0\211D\202;
0\207" . [cl--loop-args cl--loop-accum-vars cl--loop-bindings cl--loop-accum-var cl--loop-result into make-symbol "--cl-var--"])(#$ . 35205) nil 5 "\n\n(fn DEF &optional FUNC)"])
#@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 #@400 ("\301\211\203c
0@\242\302=\203V
0\303@!@\304=\203V
0A\203H
0\305@!\211A@)\242\302=\2034
0A@A\202;
0\211A@)C\244\211AA)B\262\202
0\305\211A\262@!A\262

\202
0\211A\262@B\262\202
0

\237\206j
0\304C\262

A\203w
0\306B\202y
0

@

\211\203\214
0\307\302\307\310\"BC\"\202\215
0\211A\203\230
0\306

B\202\232
0\211@\262

E\207" . [x nil progn last t butlast and append (t)])(#$ . 35844) nil 12 (#$ . 35509)])
#@88 The Common Lisp `do' loop.

(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)
(defalias 'cl-do '(macro . #[642 #@48 ("\300\301$\207" . [cl-expand-do-loop nil])(#$ . 36409) nil 8 (#$ . 36283)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-do lisp-indent-function 2 edebug-form-spec ((&rest &or symbolp (symbolp &optional form form)) (form body) cl-declarations body)] 4)
#@89 The Common Lisp `do*' loop.

(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)
(defalias 'cl-do* '(macro . #[642 #@46 ("\300\301$\207" . [cl-expand-do-loop t])(#$ . 36820) nil 8 (#$ . 36692)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-do* lisp-indent-function 2 edebug-form-spec cl-do] 4)
(defalias 'cl-expand-do-loop #[1028 #@399 ("\300\301\203\n
0\302\202
0\303\304\305\"\306\307@D\310\304\311
\"\312\301\"\262

\211\205=
0	\2042
0\211A\2046
0\313\2027
0\314\315\310\"BC\262

\"BBA\206I
0\316BBBE\207" . [cl-block nil let* let mapcar #[257 "\211:\203\f
0\211@

A@D\207\207" [] 3 "\n\n(fn C)"] while not append #[257 "\211:\205
0\211AA\205
0\211@\3008D\207" [2] 4 "\n\n(fn C)"] delq setq cl-psetq apply (nil)])(#$ . 37060) nil 17 "\n\n(fn STEPS ENDTEST BODY STAR)"])
#@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 #@100 ("\300\301\302K\303=\203

0\304\202
0\302BBE\207" . [cl-block nil dolist cl-dolist cl--dolist])(#$ . 37789) nil 7 (#$ . 37521)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-dolist edebug-form-spec ((symbolp form &optional form) cl-declarations body) 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 #@103 ("\300\301\302K\303=\203

0\304\202
0\302BBE\207" . [cl-block nil dotimes cl-dotimes cl--dotimes])(#$ . 38357) nil 7 (#$ . 38097)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-dotimes edebug-form-spec cl-dolist lisp-indent-function 1] 4)
#@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 #@131 ("\301\302\303@C\304\305\306@CBBD\211A@)\205$
0\211A@)CBBAA@FE\207" . [x cl-block nil let mapatoms function lambda])(#$ . 38822) nil 12 (#$ . 38626)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-do-symbols lisp-indent-function 1 edebug-form-spec ((symbolp &optional form form) cl-declarations body)] 4)
#@81 Like `cl-do-symbols', but use the default obarray.

(fn (VAR [RESULT]) BODY...)
(defalias 'cl-do-all-symbols '(macro . #[385 #@57 ("\301@\302\211A@)EBB\207" . [x cl-do-symbols nil])(#$ . 39296) nil 7 (#$ . 39165)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-do-all-symbols lisp-indent-function 1 edebug-form-spec ((symbolp &optional form) cl-declarations body)] 4)
#@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 #@30 ("\300

B\207" . [cl-psetf])(#$ . 39807) nil 3 (#$ . 39564)]))
(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 #@311 ("\300\301!\300\302!\300\303!\300\304!\305\306D\307\nD\nD\310\311\fBBD\312BF\313\314\315\316\nD\315\317\316\fDEE\nEE\320\315\321\n\322\323DDFDFE\207" . [make-symbol "cl--progv-body" "binds" "syms" "vals" progn defvar let* lambda nil (nil) while push list pop 'quote eval 'let quote funcall])(#$ . 40397) nil 20 (#$ . 39917)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-progv lisp-indent-function 2 edebug-form-spec (form form body)] 4)
(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 #@402 ("\211@=\203\n
0A\207\211	\236\211\203<
0\303\304\305\306\307\310\311!\312\"\313\314%D\315\304\316\303EDC\217\203<
0\211AAA@AA@\211A@)\202F
0\317D

B\211\262

\207" . [cl--labels-convert-cache macroexpand-all-environment x #1=#:err funcall make-byte-code 0 "\300AA@\211A@)\302=\207" vconcat vector [x cl-labels-args] 3 "\n\n(fn)" error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] function])(#$ . 41041) nil 11 (#$ . 40917)])
#@133 Make local function definitions.
Like `cl-labels' but the definitions are not recursive.

(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-flet '(macro . #[385 #@428 ("\301\211\2038
0\211@\302\303\304@\"!\211\305\306ABDDB\262

@\306\307\310\311\312D\313BBBEBB\262\210

A\266\202\202
0\210\314\237\315\316\317B\320\236\203M
0\202S
0\320\321BB\"!BB\207" . [macroexpand-all-environment nil make-symbol format "--cl-%s--" cl-function lambda (&rest cl-labels-args) cl-list* 'funcall quote (cl-labels-args) let macroexp-unprogn macroexpand-all progn function cl--labels-convert])(#$ . 41657) nil 14 (#$ . 41483)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-flet lisp-indent-function 1 edebug-form-spec ((&rest (cl-defun)) cl-declarations body)] 4)
#@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 #@114 ("

\204
0\300

!\207

A\204
0\301BB\207\301\211A\262@C\302BBE\207" . [macroexp-progn cl-flet cl-flet*])(#$ . 42463) nil 7 (#$ . 42281)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-flet* lisp-indent-function 1 edebug-form-spec cl-flet] 4)
#@214 Make temporary function bindings.
The bindings can be recursive and the scoping is lexical, but capturing them
in closures will only work if `lexical-binding' is in use.

(fn ((FUNC ARGLIST BODY...) ...) FORM...)
(defalias 'cl-labels '(macro . #[385 #@395 ("\301\211\2038
0\211@\302\303\304@\"!\211\305\306ABDDB\262

@\306\307\310\311\312D\313BBBEBB\262\210

A\266\202\202
0\210\314\315\237BB\316\236\203J
0\202O
0\316\317BB\"\207" . [macroexpand-all-environment nil make-symbol format "--cl-%s--" cl-function lambda (&rest cl-labels-args) cl-list* 'funcall quote (cl-labels-args) macroexpand-all letrec function cl--labels-convert])(#$ . 42996) nil 14 (#$ . 42739)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-labels lisp-indent-function 1 edebug-form-spec cl-flet] 4)
#@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 #@223 ("

A\203
0\302@C\302ABBE\207

\204
0\303

B\207

\211@@)\304\211@A)\"\305

@!\210\306\303B\307ABB	B\"\207" . [x macroexpand-all-environment cl-macrolet progn cl--transform-lambda eval macroexpand-all lambda])(#$ . 43739) nil 10 (#$ . 43555)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-macrolet lisp-indent-function 1 edebug-form-spec ((&rest (&define name (&rest arg) cl-declarations-or-string def-body)) cl-declarations body)] 4)
(defconst cl--old-macroexpand (byte-code "\301\300!\203\302K\303=\203\207\302K\207" [cl--old-macroexpand boundp macroexpand cl--sm-macroexpand] 2))
#@259 Special macro expander used inside `cl-symbol-macrolet'.
This function replaces `macroexpand' during macro expansion
of `cl-symbol-macrolet', and does the same thing as `macroexpand'
except that it additionally expands symbol macros.

(fn EXP &optional ENV)
(defalias 'cl--sm-macroexpand #[513 #@981 ("

C

\211	@\"\240\210\303

@9\203-
0\304@!\236A\205\254
0

\304@!\236\211A@)\240\202\254
0

@:\203\253
0

@@@A

\305=\203
0\306\307\310\311\312\313\n!\314\"\315\316%@A\"\211\211\203g
0\211@9\203g
0\211\211AA)\262

\202R
0\211\203s
0\317B\240\202z
0\305B\240\210\320\266\202\202\246
0

\321>\204\211
0\320\202\246
0\211:\203\237
0\211@

A$\266\202\202\246
0\320\211$\266\202\202\254
0\320\262

\204
0\211@)\207" . [macroexpand-all-environment cl--old-macroexpand x #[1028 "\301\211\211\211\203H
0\211@\2119\203
0\211\202
0\211@\302

!	\236\211A\204$
0\202;
0\211\211A@)\303\262\2119\2045
0\303\262\211\243B\262

B\262\266

A\266\202\202
0\210

\205o
0\203d
0@@\304=\203`
0\305\202h
0\306\202h
0@@\237BB\240\207" [x nil symbol-name t let cl-letf cl-letf*] 14 "\n\n(fn EXP ENV BODY BINDINGS)"] symbol-name setq mapcar make-byte-code 257 "\301

\300\"\207" vconcat vector [cl--sm-macroexpand] 4 "\n\n(fn F)" setf nil (let let*)])(#$ . 44667) nil 14 (#$ . 44366)])
#@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 #@377 ("

A\203
0\302@C\302ABBE\207

\204
0\303

!\207\304K\305\306\307\310\311\312!\313\"\314\315%DC\216\304\316M\210\317\320B\321\211@@)!@A@D	B\")\207" . [x macroexpand-all-environment cl-symbol-macrolet macroexp-progn macroexpand funcall make-byte-code 0 "\301\300M\207" vconcat vector [macroexpand] 2 "\n\n(fn)" cl--sm-macroexpand macroexpand-all progn symbol-name])(#$ . 45951) nil 11 (#$ . 45688)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-symbol-macrolet lisp-indent-function 1 edebug-form-spec ((&rest (symbol sexp)) cl-declarations body)] 4)
#@396 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 `cl-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 #@218 ("\300\301!\302C\303D\304\305\306\307\310\311		\"\312\"\313\314%\"BBB\207" . [make-symbol "--cl-var--" -1 let* mapcar make-byte-code 257 "\211\302\301\211@T\240\300ED\207" vconcat vector [nth] 5 "\n\n(fn V)"])(#$ . 46990) nil 15 (#$ . 46538)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-multiple-value-bind lisp-indent-function 2 edebug-form-spec ((&rest symbolp) form body)] 4)
#@351 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
`cl-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 #@352 ("

\204\n
0\300

\301BB\207

A\204
0\302@\303DE\207\304\305!\306C\307DC\310\302\211A\262	@\303DE\302\311\312\313\314\315\316\317\320\"\321\"\322\323%\f\"\"BEE\207" . [progn (nil) setq car make-symbol "--cl-var--" 0 let prog1 apply nconc mapcar make-byte-code 257 "\211\302\301\211@T\240\300ED\207" vconcat vector [nth] 5 "\n\n(fn V)"])(#$ . 47812) nil 19 (#$ . 47405)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-multiple-value-setq lisp-indent-function 1 edebug-form-spec ((&rest symbolp) form)] 4)
#@41 Equivalent to `progn'.

(fn &rest BODY)
(defalias 'cl-locally '(macro . #[128 #@27 ("\300

B\207" . [progn])(#$ . 48439) nil 3 (#$ . 48355)]))
(put 'cl-locally 'edebug-form-spec t)
#@81 At present this ignores _TYPE and is simply equivalent to FORM.

(fn TYPE FORM)
(defalias 'cl-the '(macro . #[514 #@15 ("\207" . [])(#$ . 48663) nil 3 (#$ . 48543)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-the lisp-indent-function 1 edebug-form-spec (cl-type-spec form)] 4)
(defvar cl-proclaim-history t)
(defvar cl-declare-stack t)
(defalias 'cl-do-proclaim #[514 #@1043 ("\211\203

0<\203

0

B

\242\306=\203#
0\307\301!\203\335
0\310A	\"\202\335
0

\242\311=\203K
0

A\211\262\203\335
0

@\312N\313>\204A
0\314\315@\"\210\316@\312\317#\210\202*
0

\242\320=\203m
0

A\211\262\203\335
0

@\312N\317=\203R
0\316@\312\321#\210\202R
0

\242\322=\203\237
0\323A\236A@\324\236\325A\236A@\326\236

\203\217
0

@

A@\211\203\232
0\211@\211A@\266\202\335
0

\242\327=\203\335
0\307\330!\203\335
0

A\211\262\203\335
0

@:\203\254
0

@A@\331=\203\320
0\332\211@@)!\210\202\254
0\333\211@@)!\210\202\254
0\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 x])(#$ . 48942) nil 7 "\n\n(fn SPEC HIST)"])
(byte-code "\301!\211\203\302
\211A\262@\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 #@147 ("\301 \203 
0\211\203 
0<\203
0\211@B\302

\211A\262@\303\"\210\202
0\303\207" . [cl-declare-stack cl--compiling-file cl-do-proclaim nil])(#$ . 50418) nil 4 (#$ . 50159)]))
#@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 #@455 ("\211\301\302\203B
0@9\203
0\303A@\"\203
0\302\262@

>\203&
0\304\305@\"\210\211A\262@

B\262

\2048
0\304\306!\210\211A\262@\210\202
0

\203P
0\307\310B\311BB\202\205
0\312!\262\313\211A@)@E\211AA)\211\262\203~
0\313\211A@)\314@EE\262

\202_
0\307

\315BB\262

\207" . [x 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)])(#$ . 50850) nil 11 (#$ . 50605)]))
(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 #@341 ("\300\301\302\303\304\305!\306\"\307\310%\"\207" . [gv-get make-byte-code 514 "\300\301

!\203
0\211\202
0\302\303!\304\305\306DE\307\310D!\311BB\312EF

=\2030
0\211\2027
0\313DC\"\207" vconcat vector [macroexp-copyable-p make-symbol "ttag" if eq car progn cddr (t) cl--do-remf macroexp-let*] 10 "\n\n(fn TVAL SETTER)"])(#$ . 51618) nil 10 (#$ . 51386)]))
(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 #@239 ("\211\204
0

\207

9\203
0\300\301\302BEE\207\303\304\305\306\307\310!\311\"\312\313%\"\207" . [prog1 setq cl-shiftf gv-get make-byte-code 514 "\301\302\300B!E\207" vconcat vector [prog1 cl-shiftf] 7 "\n\n(fn GETTER SETTER)"])(#$ . 52281) nil 10 (#$ . 52047)]))
(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 #@515 ("\300\301\302\">\2040
0\211A\205m
0\300

@A\203&
0

\211A\262@@D\244\262\202
0\303\304@D\"B\207\305

!\306\307!\211CA\203X
0\211\310\211A\262@\311\312\313\314\315!\316\"\317\320%\"\240\210\2028
0\310@\311\312\321\314\315\"\322\"\323\320%\"\266\203\207" . [nil mapcar symbolp cl-psetf append reverse make-symbol "--cl-rotatef--" gv-get make-byte-code 514 "\301\300@!E\207" vconcat vector [prog1] 6 "\n\n(fn GETTER SETTER)" "\302\300DC\303\301@!\304BB\"\207" [macroexp-let* progn (nil)] 7])(#$ . 52850) nil 13 (#$ . 52611)]))
(put 'cl-rotatef 'edebug-form-spec '(&rest place))
(defalias 'cl--letf #[1028 #@945 ("\2040
0

\204
0\204
0\300

!\207\301\302\303\304\"\"\305\300\302\306\307\303\310\n\"\"\"!\303\311\"BBE\207@\312

@\313\314\315\316\317%\320\"\321\322%\"\207" . [macroexp-progn let* append mapcar #[257 "\211@

A\211@

A\211@

A\211@

A

\n\211D\266\204\207" #1=[] 15 "\n\n(fn X)"] unwind-protect delq nil #[257 "\211:\205<
0\211@

A\211:\205:
0\211@

A\211:\2058
0\211@

A\211:\2056
0\211@

A\211?\2054
0

\n!\266\204\266\202\266\202\266\202\266\202\207" #1# 15 "\n\n(fn X)"] #[257 "\211@

A\211@

A\211@

A\211@

A

\n

!\266\204\207" #1# 15 "\n\n(fn X)"] gv-get make-byte-code 514 "\304\211A@)\306

!\203
0\211\202
0\307\310!\304@9\2031
0\311\300A\304A\203&
0\202(
0D\301B\302\303$\202K
0\311\300A\301\307\312!\304A\205D
0CBBB\302B\303$

=\203U
0\211\202\\
0\313DC\"\207" vconcat vector [x macroexp-const-p make-symbol "vnew" cl--letf "old" macroexp-let*] 12 "\n\n(fn GETTER SETTER)"])(#$ . 53484) nil 17 "\n\n(fn BINDINGS SIMPLEBINDS BINDS BODY)"])
#@531 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.

(fn ((PLACE VALUE) ...) BODY...)
(defalias 'cl-letf '(macro . #[385 #@105 ("

A\204
0

\211@A)\203
0

\211@@)9\203
0\301BB\207\302\303\211$\207" . [x let cl--letf nil])(#$ . 55071) nil 8 (#$ . 54499)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-letf lisp-indent-function 1 edebug-form-spec ((&rest (gate gv-place &optional form)) body)] 4)
#@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 #@112 ("\300!\211\203
0\211@\301

CBBC\262

A\266\202\202
0\210\302

!\207" . [reverse cl-letf macroexp-progn])(#$ . 55609) nil 7 (#$ . 55375)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-letf* lisp-indent-function 1 edebug-form-spec cl-letf] 4)
#@177 Set PLACE to (FUNC PLACE ARGS...).
FUNC should be an unquoted function name.  PLACE may be a symbol,
or any generalized variable allowed by `setf'.

(fn FUNC PLACE &rest ARGS)
(defalias 'cl-callf '(macro . #[642 #@207 ("\300\301\302\303\304\305	\"\306\"\307\310%\"\207" . [gv-get make-byte-code 514 "

\301B

\3009\203
0\300B\202
0\302\303\300DBB!\207" vconcat vector [funcall function] 7 "\n\n(fn GETTER SETTER)"])(#$ . 56102) nil 12 (#$ . 55883)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-callf lisp-indent-function 2 edebug-form-spec (cl-function place &rest form)] 4)
#@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 #@421 ("\300!\203
0\301!\203
09\203
0\302BBBE\207\303

!\203'
0\211\202*
0\304\305!\306\307\310\311\312\313\f\n	#\314\"\315\316%\"

=\203H
0\211\202O
0\317DC\"\207" . [cl--safe-expr-p cl--simple-expr-p setf macroexp-const-p make-symbol "a1" gv-get make-byte-code 514 "\302\301BB

\3009\203
0\300B\202
0\303\304\300DBB!\207" vconcat vector [funcall function] 7 "\n\n(fn GETTER SETTER)" macroexp-let*])(#$ . 56683) nil 16 (#$ . 56495)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-callf2 lisp-indent-function 3 edebug-form-spec (cl-function form place &rest form)] 4)
#@796 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 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, or :include.

Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
SLOT-OPTS are keyword-value pairs for that slot.  Currently, only
one keyword is supported, `:read-only'.  If this has a non-nil
value, that slot cannot be set via `setf'.

(fn NAME SLOTS...)
(defalias 'cl-defstruct '(macro . #[385 #@4584 ("

:\203\n
0

@\202
0

\243\302\211\303!\304P\305\306\307\"!\302\305\306\310	\"!\305\306\311\n\"!\302\211\312 \2035
0\2026
0\313\302\305\306\314\"!\305\306\315\"!\302\211\211\211\211\211\211@;\203e
0\316\317D\320\211A\262@FB\262\321\322\323\"B\262\203N

@:\203\204
0\211@@)\202\207
0@\211A\262@\243

\324=\203\253
0\211\203I

\211@\203\245
0\303

@!\202\246
0\325\262\202I



\326=\203\325
0\211A\203\312
0\211@=\203\301
0\302\262\211B\262\202I

\211\203I

\211@\262\202I



\327=\203\346
0\211\203I

\211@\262\202I



\330=\203\367
0\211\203I

\211@\262\202I



\331=\203

\211@\262\f\322\332A\"\262	\202I



\333=\203

\211@\262\202I



\334=\203%

\211@\262\202I



\335=\2031

\336\262\202I



\337=\203D

\340

@\341\"\244\262\202I

\342\343\"\210\266\202n
0\f\203d

\344\345\346D\347BB\350BB\262
\202\223

\204\223

	\203t

	\351N\203\223

\336\262\f	\204\200

\203\206

\f?\205\221

\344\352\306\353\"\354BBD\262
	\2033	\355N\n\356N

\204\252

\342\357
\"\210\203\275



@=\204\275

\342\360\"\210\203\350

\211@@)

\236\206\332

\342\361\n\211@@)#

>	\211A\262@\240\210\202\275

\362

\363\364\236\"\"\262

@\262\364\236\262

\211A@)\203\262\336\262\211\203.\365\317
D\305\306\315\"!EB\262\211\366N\262

\202\266\202T\203N\367>\204C\342\370\"\210\203T\262	\202T\371\262\372\262\204b\363\364\236\"\262\373DB\262\205\305G\364\236>GZ\371=\203\233\374\375\376\377GE\201@
0\201A
0\201B
0E
EF\202\303\211\201C
0U\203\257\201@
0\201D
0\nE\202\303\374\201E
0\201@
0\201F
0\201G
0BB\fEE\262

\262

\205\362\n\201C
0V\205\362

A@@\201H
0=\203\361\n\201I
0U\203\361\374AAAB\202\362

\262

\201C
0\211\203\211

A\262@\211@\211\201J
0>\203%\302B\262\211\364=\205\317
DB\262\202\373\211\236\2034\342\201K
0#\210\305\306\201L
0#!

B\262A@B\262\201M
0

\201N
0\362	\205m\201O
0\n\342\201P
0\317	D\317$DFEC\371=\203\200\201A
0\201B
0E\202\231	\201C
0U\203\217\201Q
0\202\231\201F
0\n\201R
0BBC\"BBBB\262\211\336BB\262\201S
0\211AA)>\211A@)\203\327\201T
0

\201U
0\201V
0\342\201W
0\317DEEEB\262\203\372\352\306\201X
0\"\201Y
0BB\201Z
0\201[
0B\201\\
0BBD\244\210\210\266

T\262\202\371\266\237\262\237\262
\203H

\203H\201M
0\201]
0@\374=\2031\362\201^
0\"\2028\374\201_
0BBFB\262
\201`
0BB\262\203d\201a
0\201b
0BBB\262\336BB\262\203~\201c
0\363\302\201d
0!\"BDB\262\203\366\211@@)\211A\262@\211A@)\201e
0

!\201f
0\201g
0\201h
0\201i
0\201j
0\371!\201k
0\"\201l
0\201m
0%#\201M
0\201n
0\317\302
_BDBBBFB\262\201o
0\344\322\201p
0\"B!\203\361\336B\nB\262\n\266\202~\203\f\201q
0\336D\244\210\201r
0\201s
0\317\fDDEB\262\201t
0\201u
0\316\317D\201v
0\317DF\316\317D\201w
0\317\336=DDF\316\317D\201x
0\317DF\316\317D\201y
0F\322\201z
0
\"BBBBBBB\262\344\317DB\237B\207" . [cl-optimize-safety x nil symbol-name "-" intern format "make-%s" "copy-%s" "%s-p" cl--compiling-file 3 "cl-struct-%s" "cl-struct-%s-tags" put quote 'structure-documentation (cl-tag-slot) mapcar #[257 "\211:\203
0\207\211C\207" #1=[] 2 "\n\n(fn X)"] :conc-name "" :constructor :copier :predicate :include #[257 "\211:\203
0\207\211C\207" #1# 2 "\n\n(fn X)"] :print-function :type :named t :initial-offset make-list (cl-skip-slot) error "Slot option %s unrecognized" progn funcall function (cl-x cl-s cl-n) (t) cl-struct-print princ "#S(%s" (cl-s) cl-struct-type cl-struct-slots "%s is not a struct name" ":type disagrees with :include for %s" "No slot %s in included struct %s" append delq cl-tag-slot cl-pushnew cl-struct-include (vector list) "Invalid :type specifier: %s" vector true defvar and (vectorp cl-x) >= (length cl-x) memq aref cl-x 0 (car-safe cl-x) (consp cl-x) nth (cl-x) vectorp 1 (cl-tag-slot cl-skip-slot) "Duplicate slots named %s in %s" "%s%s" cl-defsubst (cl-x) or "%s accessing a non-%s" (car cl-x) (cl-x) :read-only gv-define-expander lambda (_cl-do _cl-x) "%s is a read-only slot" " %s" (cl-s) prin1 (cl-x) (cl-s) (cl-x) (t) (t) error-free defun ((x) (copy-sequence x)) &key copy-sequence cl--arglist-args cl-mapcar make-byte-code 514 "

\300>\203
0

\207\207" vconcat #1# 4 "\n\n(fn S D)" &cl-defs cl--safe-expr-p cl-second (princ ")" cl-s) setq list cl-eval-when (compile load eval) 'cl-struct-slots 'cl-struct-type 'cl-struct-include 'cl-struct-print #[257 "\300\301@D\302\301ADF\207" [put quote 'side-effect-free] 6 "\n\n(fn X)"]])(#$ . 58139) nil 41 (#$ . 57296)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\307#\207" [put cl-defstruct doc-string-elt 2 lisp-indent-function 1 edebug-form-spec (&define [&or symbolp (gate symbolp &rest (&or [":conc-name" symbolp] [":constructor" symbolp &optional cl-lambda-list] [":copier" symbolp] [":predicate" symbolp] [":include" symbolp &rest sexp]))] [&optional stringp] &rest &or symbolp (symbolp def-form &optional ":read-only" sexp))] 4)
#@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 #@162 ("\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 '('*)])(#$ . 63382) nil 13 (#$ . 63204)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-deftype edebug-form-spec cl-defmacro doc-string-elt 3] 4)
(defalias 'cl--make-type-test #[514 #@1169 ("\2119\203r
0\211\301N\203
0\302\301N \"\207\211\303>\203
0\207\211\304=\203$
0\304D\207\211\305=\203.
0\305D\207\211\306=\2038
0\307D\207\211\310=\203B
0\311D\207\211\312=\203L
0\313D\207\211\314>\203V
0\315D\207\316

!\317

\320P!\321

!\203j
0\211D\202q
0\317\322P!D\207\211@\301N\203\205
0\302\323@\301NA\"\"\207\211@\324>\203\362
0\325\326\327\302@\"\211A@)\330>\203\243
0\326\202\304
0\211A@):\203\271
0\331A@@E\202\304
0\332\211A@)EAA@\333>\203\321
0\326\202\357
0AA@:\203\346
0\334AA@@E\202\357
0\335AA@EF\"\207\211@\336>\203

\211@\337\340\341\342\343\344!\345\"\346\347%A\"B\207\211@\350>\203!

\327\351\352ADE\353BB\207\211@\354=\2031

\211\211A@)D\207\355\356\"\207" . [x cl-deftype-handler cl--make-type-test (nil t) null atom float cl-floatp-safe real numberp fixnum integerp (character string-char) characterp symbol-name intern "p" fboundp "-p" apply (integer float real number) delq t and (* nil) > >= (* nil) < <= (and or not) mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [cl--make-type-test] 4 "\n\n(fn X)" (member cl-member) cl-member quote (t) satisfies error "Bad type spec: %s"])(#$ . 63744) nil 11 "\n\n(fn VAL TYPE)"])
#@98 Check that OBJECT is of type TYPE.
TYPE is a Common Lisp-style type specifier.

(fn OBJECT TYPE)
(defalias 'cl-typep #[514 #@69 ("

\301\302\300\"!)\207" . [cl--object eval cl--make-type-test])(#$ . 65088) nil 6 (#$ . 64959)])
#@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 #@379 ("\302 \203
0\303W\204
0	\303U\205T
0\304\303\"\203
0\202
_
0\305\306!\307\310\"\311\312\313\2060
0\314D\314DFEE

=\203G
0\315

\316BB\202R
0\317DC\320BBB\266\202\207" . [cl-optimize-speed cl-optimize-safety cl--compiling-file 3 cl--simple-expr-p make-symbol "--cl-var--" or cl--make-type-test signal 'wrong-type-argument list quote progn (nil) let (nil)])(#$ . 65390) nil 13 (#$ . 65196)]))
(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 #@371 ("\302 \203
0\303W\204
0	\303U\205F
0\205
0\304\305\306\307A\"\"\310\311\2034
0\312\313\"BB\202@
0\314\315\316\317DBBEE\320BB\262

\207" . [cl-optimize-speed cl-optimize-safety cl--compiling-file 3 delq nil mapcar #[257 "\300

!?\205
0\211\207" [macroexp-const-p] 3 "\n\n(fn X)"] progn or error append signal 'cl-assertion-failed list quote (nil)])(#$ . 66298) nil 13 (#$ . 65889)]))
(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 #@485 ("

\302

:\203
0

\211A\262@

B\262

\202
0\211\237\205
0\303D\244\262\266\304\305\306\307D\310\311\312\313	>\203;
0\314\313\n\"\202?
0\315	BBBDF\316\317\206W
0\320\301!\205W
0	;\205W
0	DC\321\317\306\307D\322BBEEF\207" . [buffer-file-name byte-compile-current-file nil &rest cl-eval-when (compile load eval) put quote 'compiler-macro cl-function lambda &whole delq _cl-whole-arg let file boundp if ('compiler-macro-file (purecopy (file-name-nondirectory file)))])(#$ . 67487) nil 13 (#$ . 66764)]))
(put 'cl-define-compiler-macro 'edebug-form-spec 'cl-defmacro)
#@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 #@245 ("\211\242\301

9\2031
0

\302N\211\262\2041
0\303!\2031
0

K\211\242)\304=\203*
0\305K\"\2031
0

K\262\202
0\211\205A
0\306\211A#\211\262=?\266\202\204
0
0\207" . [object nil compiler-macro fboundp autoload autoload-do-load apply])(#$ . 68353) nil 9 (#$ . 68076)])
(defvar cl--active-block-names nil)
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\210\300\310\302\311#\210\304\211\203+\300\310\305\306\307!!#\210\207" [put cl--block-wrapper compiler-macro #[514 "\211A@A@\303B\211B\304\305\211AA)B\n\"
A\203&\306A@ABB\202'\211)\207" [cl--active-block-names x macroexpand-all-environment nil macroexpand-all progn catch] 8 "\n\n(fn CL-WHOLE-ARG CL-FORM)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/cl-macs.el" compiler-macro-file purecopy file-name-nondirectory cl--block-throw #[771 "
A@\236\211\203
\211\301\241\210\210\302E\207" [cl--active-block-names t throw] 6 "\n\n(fn CL-WHOLE-ARG CL-TAG CL-VALUE)"]] 7)
#@240 Define NAME as a function.
Like `defun', except the function is automatically declared `inline',
ARGLIST allows full Common Lisp conventions, and BODY is implicitly
surrounded by (cl-block NAME ...).

(fn NAME ARGLIST [DOCSTRING] BODY...)
(defalias 'cl-defsubst '(macro . #[642 #@391 ("\300!\211\301B\302

!?\203$
0\303@\"\304=\203$
0\211A\262@\210\202
0\301?\205e
0\305\306	>\203?
0\307\310\311BBB\202C
0\311	B\312\313	D\313\314
BBD\315\306>\205Z
0\310	
BBBBBBF\316			BBBE\207" . [cl--arglist-args progn cl--safe-expr-p cl--expr-contains 1 cl-define-compiler-macro &key &whole cl-whole &cl-quote cl--defsubst-expand quote cl-block nil cl-defun])(#$ . 69619) nil 18 (#$ . 69334)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl-defsubst edebug-form-spec cl-defun lisp-indent-function 2] 4)
(defalias 'cl--defsubst-expand #[1413 #@507 ("C\203
0\301\302B!\204
0\202u
0\303!\203
0\211\304\240\210\305C\306\305\307\310\311\312\313\314	\f\n#\315\"\316\317%#\"

@\204B
0\202c
0

@A\204]
0\320@\211@A)@\211@@)\n#\202c
0\321@	\"\262\211\203q
0\322

	E\202s
0\266\202\207" . [x cl--safe-expr-p progn cl--simple-exprs-p t nil delq cl-mapcar make-byte-code 514 "\300@\204
0\303

!\203
0\302B\302@B\240\210\301\205
_
0



D\207



D\207" vconcat vector [macroexp-const-p] 5 "\n\n(fn ARGN ARGV)" cl-subst cl-sublis let])(#$ . 70215) nil 20 "\n\n(fn ARGNS BODY SIMPLE WHOLE UNSAFE &rest ARGVS)"])
(defalias 'cl--compiler-macro-member #[899 #@215 ("\211G\300U\205
0\211@\301=\205
0\302

A@!\211\303=\203 
0\304E\202?
0\211\305=\203-
0\306E\202?
0

\2037
0\211\307=\203>
0\310E\202?
0\207" . [2 :test cl--const-expr-val eq memq equal member eql memql])(#$ . 70846) nil 8 "\n\n(fn FORM A LIST &rest KEYS)"])
(defalias 'cl--compiler-macro-assoc #[899 #@299 ("\211G\300U\205
0\211@\301=\205
0\302

A@!\211\303=\203 
0\304E\202\\
0\211\305=\203-
0\306E\202\\
0\307!\203[
0

\203=
0\211\310=\203[
0\302!\211\247\205H
0\211\250?\262

\203T
0\306E\202\\
0\304E\202\\
0\207" . [2 :test cl--const-expr-val eq assq equal assoc macroexp-const-p eql])(#$ . 71163) nil 8 "\n\n(fn FORM A LIST &rest KEYS)"])
(defalias 'cl--compiler-macro-adjoin #[899 #@125 ("\300!\203#
0\300!\203#
0\301

>\204#
0\302\303BBB\304EF\207\207" . [cl--simple-expr-p :key if cl-member cons])(#$ . 71565) nil 10 "\n\n(fn FORM A LIST &rest KEYS)"])
(defalias 'cl--compiler-macro-get #[1027 #@75 ("\211\203\f
0\300\301DF\207\302E\207" . [cl-getf symbol-plist get])(#$ . 71791) nil 8 "\n\n(fn FORM SYM PROP &optional DEF)"])
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\210\310\211\203*\211@\300
\311\312#\210
A\266\202\202\210\313\314!\210\315\316\317\"\210\315\320\321\"\210\322\323!\210\324\325!\207" [put cl-typep compiler-macro #[771 "\300
!\203,
\301
!\203\211\202\302\303!\304
\305!\"
=\203$\211\202+\306DC\"\207\207" [macroexp-const-p macroexp-copyable-p make-symbol "temp" cl--make-type-test cl--const-expr-val macroexp-let*] 9 "\n\n(fn FORM VAL TYPE)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/cl-macs.el" compiler-macro-file purecopy file-name-nondirectory (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) side-effect-free t cl-proclaim (inline cl-floatp-safe cl-acons cl-map cl-concatenate cl-notany cl-notevery cl--set-elt cl-revappend cl-nreconc gethash) mapc #[257 "\300
\301\302#\207" [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" [put side-effect-free error-free] 5 "\n\n(fn X)"] (eql cl-floatp-safe cl-list* cl-subst cl-acons cl-equalp cl-random-state-p copy-tree cl-sublis) run-hooks cl-macs-load-hook provide cl-macs] 7)