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



(defvar macroexpand-all-environment nil)
#@137 Return ORIGINAL-CONS if the car/cdr of it is `eq' to CAR and CDR, respectively.
If not, return (CAR . CDR).

(fn CAR CDR ORIGINAL-CONS)
(defalias 'macroexp--cons #[771 "
@=\203

A=\203\207B\207" [] 5 (#$ . 126)])
#@377 Return a list of the results of evaluating BODY for each element of LIST.
Evaluate BODY with VAR bound to each `car' from LIST, in turn.
Return a list of the values of the final form in BODY.
The list structure of the result will share as much with LIST as
possible (for instance, when BODY just returns VAR unchanged, the
result will be eq to LIST).

(fn (VAR LIST) BODY...)
(defalias 'macroexp--accumulate '(macro . #[385 "
@A@\300\301!\300\302!\300\303!\300\304!\305D\306BD	\257\307\310D\311\n\312D\313B\257\314\315\fE\307\316\315
\fED\317\320D
EE\311\f\321DE\317\n
E\257\311\321\nDE\257\322\323DEF\207" [make-symbol "shared" "unshared" "tail" "new-el" let* (nil) while consp setq car progn unless eq not push pop cdr nconc nreverse] 20 (#$ . 353)]))
(byte-code "\300\301\302\303#\300\207" [function-put macroexp--accumulate lisp-indent-function 1] 4)
#@170 Return FORMS with macros expanded.  FORMS is a list of forms.
If SKIP is non-nil, then don't expand that many elements at the start of
FORMS.

(fn FORMS &optional SKIP)
(defalias 'macroexp--all-forms #[513 "
\300\300\211:\203N@\262\203\301U\203\302!\202#S\262
\262


=\204G=\204>\211A\262\242B\262\202+A\262\211B\262A\262\202\237\244\207" [nil 0 macroexp--expand-all] 9 (#$ . 1257)])
#@231 Return CLAUSES with macros expanded.
CLAUSES is a list of lists of forms; any clause that's not a list is ignored.
If SKIP is non-nil, then don't expand that many elements at the start of
each clause.

(fn CLAUSES &optional SKIP)
(defalias 'macroexp--all-clauses #[513 "
\300\300\211:\203G@\262
<\203\301\"\202
\262


=\204@=\2047\211A\262\242B\262\202$A\262\211B\262A\262\202\237\244\207" [nil macroexp--all-forms] 10 (#$ . 1682)])
#@21 

(fn HANDLER FORM)
(defalias 'macroexp--compiler-macro #[514 "\3001\f\301\211A#0\207\302\303@#\210
\207" [(debug error) apply message "Compiler-macro error for %S: %S"] 7 (#$ . 2152)])
#@278 Pseudo function used internally by macroexp to delay warnings.
The purpose is to delay warnings to bytecomp.el, so they can use things
like `byte-compile-warn' to get better file-and-line-number data
and also to avoid outputting the warning during normal execution.

(fn FORM)
(defalias 'macroexp--funcall-if-compiled #[257 "\300\207" [nil] 2 (#$ . 2350)])
(put 'macroexp--funcall-if-compiled 'byte-compile #[257 "\300
A@! \210\301\302!\207" [eval byte-compile-constant nil] 3 "\n\n(fn FORM)"])
#@58 Return non-nil if we're macroexpanding for the compiler.
(defalias 'macroexp-compiling-p #[0 "\301\235\207" [macroexpand-all-environment (declare-function . byte-compile-macroexpand-declare-function)] 2 (#$ . 2851)])
#@363 Return the name of the file from which the code comes.
Returns nil when we do not know.
A non-nil result is expected to be reliable when called from a macro in order
to find the file in which the macro's call was found, and it should be
reliable as well when used at the top-level of a file.
Other uses risk returning non-nil value that point to the wrong file.
(defalias 'macroexp-file-name #[0 "\302!@\211;\203
\211\206\303\301!\205	\207" [current-load-list byte-compile-current-file last boundp] 3 (#$ . 3076)])
(defvar macroexp--warned (make-hash-table :test 'equal :weakness 'key))
#@26 

(fn MSG FORM CATEGORY)
(defalias 'macroexp--warn-wrap #[771 "\300\301#\302\303\304DDE\207" [make-closure #[0 "\302\301!\205\n\303\304\300\"\207" [V0 V1 byte-compile-warning-enabled-p byte-compile-warn "%s"] 3] progn macroexp--funcall-if-compiled quote] 8 (#$ . 3675)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias macroexp--warn-and-return macroexp-warn-and-return nil make-obsolete "28.1"] 4)
#@320 Return code equivalent to FORM labeled with warning MSG.
CATEGORY is the category of the warning, like the categories that
can appear in `byte-compile-warnings'.
COMPILE-ONLY non-nil means no warning should be emitted if the code
is executed without being compiled first.

(fn MSG FORM &optional CATEGORY COMPILE-ONLY)
(defalias 'macroexp-warn-and-return #[1026 "\204\207\302 \203%:\203\303\"\203\207\304\211#\210\305#\207\211\204=\306\307	;\2038\310	!\311P\2029\312#\210\207" [macroexp--warned load-file-name macroexp-compiling-p gethash puthash macroexp--warn-wrap message "%sWarning: %s" file-relative-name ": " ""] 8 (#$ . 4104)])
#@35 

(fn FUN OBSOLESCENCE-DATA TYPE)
(defalias 'macroexp--obsolete-warning #[771 "
@\3008\301\302\203\303\304Q\202\305;\203%\306\307!P\2023\2032\301\310\"\2023\311%\207" [2 format-message "`%s' is an obsolete %s%s%s" " (as of " ")" "" "; " substitute-command-keys "; use `%s' instead." "."] 13 (#$ . 4769)])
#@80 Perform (at most) one step of macroexpansion.

(fn FORM &optional ENVIRONMENT)
(defalias 'macroexpand-1 #[513 "
:\203W
@\211\236\211\203\211A\203\300
AA\"\207\207
9\203'\301!\204)\207\302K\303#\2119\203?\304
!\203?\211AB\207\211:\204F\207\211@\303=\203U\300
AA\"\207\207
\207" [apply fboundp autoload-do-load macro macrop] 8 (#$ . 5102)])
#@62 Like `macroexpand' but checking obsolescence.

(fn FORM ENV)
(defalias 'macroexp-macroexpand #[514 "\211\301\"
=\204;\242\203;@9\203;@\302N\203;@\211\302N\303\304K9\2031\305\2022\306#\307#\266\202\202<\211)\207" [macroexpand-all-environment macroexpand byte-obsolete-info macroexp-warn-and-return macroexp--obsolete-warning "alias" "macro" obsolete] 10 (#$ . 5470)])
#@28 

(fn FORM &optional NAME)
(defalias 'macroexp--unfold-lambda #[513 "\211\204\300\262

@A
A@AA\301\211\211@;\203#A\203#A\262@:\2035@@\302=\2035A\262\203\277@\303=\203[
\203J\304\305	\"\210A\204U\304\306	\"\210\307\262\202\270@\310=\203A\204m\304\311	\"\210AA\203y\304\312	\"\210\307\262\202\270
\203\231@\205\216\313BD
B\262
\301\262\202\270\204\252\204\252\301\262\314\262\202\270@@D
B\262
A\262A\262\2025\203\330\315\316\314=\203\320\317\202\321\320\n\"\n\"\207\211\203\343\321
\237BB\207\322!\207" ["anonymous lambda" nil interactive &optional error "&optional found after &rest in %s" "Nothing after &optional in %s" t &rest "Nothing after &rest in %s" "Multiple vars after &rest in %s" list too-few macroexp-warn-and-return format "attempt to open-code `%s' with too few arguments" "attempt to open-code `%s' with too many arguments" let macroexp-progn] 13 (#$ . 5862)])
#@149 Expand all macros in FORM.
This is an internal version of `macroexpand-all'.
Assumes the caller has bound `macroexpand-all-environment'.

(fn FORM)
(defalias 'macroexp--expand-all #[257 "\211C\211\242\242\301=\203\302\303\242\304\"\"\207\211\305\242\"\240\210\306
\242:\203Z

\242\242\211\307\267\202\326\242\243\310\311\312!\242#\207\242\243\211\242
\243\211\242
\243\310\313\310\310\314!\312\304\"\242AA#\f\242A#\n\242#\207\303\242\315\"\207\242\243\211:\203\242\211\242\211:\203\237\211\242\211\316=\203\234\243\211\204\230\310\317\310\303\315\"\320\242A#	\242#\207\242\207\242\207\242\207\242\207\242\207\242\243\211\242
\243\310\310\312\304\"\204\311\321\322\323\324\"\320\211\325$!\202\314\303!\n\242A#\242#\207\211:\203
\211\242\211\316=\203
\242\243\326\242!\211\242=\203\377\310\303\315\"\303!\242#\207\314
!\207\"\207\211\327=\203U
\242\243\211\242
\243\314!\303!\330:\203P
\242\211\317=\203K
\243\211:\203F
\211\242
\243\211\204?
\314B!\207\"\207\"\207
\"\207\211\"\207
\"\207
\242\207" [macroexpand-all-environment backquote-list* macroexpand macroexp--all-forms 1 macroexp-macroexpand #[514 "\300
\301\"\300\302\"\211\211\203N\211@\211\2428\211\242\303=\203F\211A@\242\304=\203F
\242\233\305\306\307A@\2119\2038\211\202?\304
A@\310BB\262
\"\"\240\210\210
A\266\202\202	\210
\204Y\311\242\312\"\207\313!\204t\3141n\315\316!\"0\210\202t\317\320\"\266\321\242\"\242
=\203\245\242\311\242\312\"\211\262\232\203\222\242\207\321\"\240\210\211\242=\203\241\207\322
!\207\322
!\207" [function-get compiler-macro funarg-positions quote lambda macroexp-warn-and-return format "%S quoted with ' rather than with #'" (\.\.\.) macroexp--all-forms 1 functionp (debug error) autoload-do-load indirect-function message "macroexp--expand-all: %S" macroexp--compiler-macro macroexp--expand-all] 15 "\n\n(fn FORM FUNC)"] #s(hash-table size 8 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (cond 43 condition-case 56 defconst 98 defvar 98 function 104 quote 165 let* 168 let 168)) macroexp--cons cond macroexp--all-clauses condition-case macroexp--expand-all 2 lambda function nil macroexp-unprogn macroexp-warn-and-return format "Empty %s body" compile-only macroexp--unfold-lambda funcall #[514 "\300BB\207" [funcall] 5 "\n\n(fn EEXP EARGS)"]] 18 (#$ . 6818)])
(byte-code "\300\211\203\211@\301
\302\303#\210
A\266\202\202
\210\304\211\203)\211@\301
\302\305#\210
A\266\202\202\210\306\211\203>\211@\301
\302\307#\210
A\266\202\202+\207" [(funcall apply mapcar mapatoms mapconcat mapc cl-mapcar maphash map-char-table map-keymap map-keymap-internal) put funarg-positions (1) (add-hook remove-hook advice-remove advice--remove-function defalias fset global-set-key run-after-idle-timeout set-process-filter set-process-sentinel sort) (2) (advice-add define-key run-at-time run-with-idle-timer run-with-timer) (3)] 6)
#@288 Return result of expanding macros at all levels in FORM.
If no macros are expanded, FORM is returned unchanged.
The second optional arg ENVIRONMENT specifies an environment of macro
definitions to shadow the loaded ones for use in file byte-compilation.

(fn FORM &optional ENVIRONMENT)
(defalias 'macroexpand-all #[513 "\211\301!)\207" [macroexpand-all-environment macroexp--expand-all] 4 (#$ . 9790)])
#@62 Parse a function BODY into (DECLARATIONS . EXPS).

(fn BODY)
(defalias 'macroexp-parse-body #[257 "\300
A\203#
@\211;\206\211\242\301>\262
\203#
\211A\262\242
B\262
\202
\211\237B\207" [nil (:documentation declare interactive cl-declare)] 5 (#$ . 10202)])
#@183 Return EXPS (a list of expressions) with `progn' prepended.
If EXPS is a list with a single expression, `progn' is not
prepended, but that expression is returned instead.

(fn EXPS)
(defalias 'macroexp-progn #[257 "\211A\203	\300
B\207\211@\207" [progn] 3 (#$ . 10472)])
#@100 Turn EXP into a list of expressions to execute in sequence.
Never returns an empty list.

(fn EXP)
(defalias 'macroexp-unprogn #[257 "\211\242\300=\203\211A\206\301\207\211C\207" [progn (nil)] 3 (#$ . 10751)])
#@81 Return an expression equivalent to \=`(let* ,BINDINGS ,EXP).

(fn BINDINGS EXP)
(defalias 'macroexp-let* #[514 "
\204\207\211\242\300=\203\300\301A@\"AABB\207\300E\207" [let* append] 6 (#$ . 10971)])
#@84 Return an expression equivalent to \=`(if ,TEST ,THEN ,ELSE).

(fn TEST THEN ELSE)
(defalias 'macroexp-if #[771 "\211\242\300=\203[
\3018\232\203\300\302A@E\303\233BBB\207\304!\303\233\232\203;\300\302\305A@DE\304\3018!BBB\207\306\304!BA@\304\3018!B\303\233\211\205U\307
BC\262
BBB\207\211\242\306=\203m\306\304!BABB\207
\242\310>\203|\311\305D#\207\300\205\206\304!BBB\207" [if 2 or 3 macroexp-unprogn not cond t (if cond) macroexp-if] 9 (#$ . 11186)])
#@1136 Evaluate BODY with SYM bound to an expression for EXP's value.
The intended usage is that BODY generates an expression that
will refer to EXP's value multiple times, but will evaluate
EXP only once.  As BODY generates that expression, it should
use SYM to stand for the value of EXP.

If EXP is a simple, safe expression, then SYM's value is EXP itself.
Otherwise, SYM's value is a symbol which holds the value produced by
evaluating EXP.  The return value incorporates the value of BODY, plus
additional code to evaluate EXP once and save the result so SYM can
refer to it.

If BODY consists of multiple forms, they are all evaluated
but only the last one's value matters.

TEST is a predicate to determine whether EXP qualifies as simple and
safe; if TEST is nil, only constant expressions qualify.

Example:
 (macroexp-let2 nil foo EXP
   \=`(* ,foo ,foo))
generates an expression that evaluates EXP once,
then returns the square of that value.
You could do this with
  (let ((foovar EXP))
    (* foovar foovar))
but using `macroexp-let2' produces more efficient code in
cases where EXP is a constant.

(fn TEST SYM EXP &rest BODY)
(defalias 'macroexp-let2 '(macro . #[899 "\300\301!\300\302!\303
D\304\305\306\206\307DE\300\310\f!DFD\311!DE\304\312E\313\314\211\f	EDEFE\207" [make-symbol "body" "exp" let* if funcall function macroexp-const-p symbol-name macroexp-progn eq macroexp-let* list] 16 (#$ . 11682)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put macroexp-let2 lisp-indent-function 3 put edebug-form-spec (sexp sexp form body)] 5)
#@202 Multiple binding version of `macroexp-let2'.

BINDINGS is a list of elements of the form (SYM EXP).  Each EXP
can refer to symbols specified earlier in the binding list.

(fn TEST BINDINGS &rest BODY)
(defalias 'macroexp-let2* '(macro . #[642 "
\204\300
!\207
:\203L
\242\211:\203G\211\242
\243\211:\203A\211\242
\243\211\204;\243\301	\302

BBB\257\207\303\304\"\207\303\304\"\207\303\304\"\207\303\304\"\207" [macroexp-progn macroexp-let2 macroexp-let2* error "No clause matching `%S'"] 17 (#$ . 13277)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put macroexp-let2* lisp-indent-function 2 put edebug-form-spec (sexp (&rest (sexp form)) body)] 5)
#@17 

(fn EXP SIZE)
(defalias 'macroexp--maxsize #[514 "\211\300W\203\207
9\203\211S\207
;\203\211G\301\245Z\207\302!\203>
G\300\211W\2039\303H\"\262\211T\262
\202$\266\211S\207
:\203[
\211\203W\211@\303
\"\262
A\266\202\202D\210\211S\207\304\207" [0 16 vectorp macroexp--maxsize -1] 7 (#$ . 13974)])
#@58 Return non-nil if EXP can be considered small.

(fn EXP)
(defalias 'macroexp-small-p #[257 "\300
\301\"\302V\207" [macroexp--maxsize 10 0] 4 (#$ . 14299)])
#@155 Non-nil if SYMBOL is constant.
If ANY-VALUE is nil, only return non-nil if the value of the symbol is the
symbol itself.

(fn SYMBOL &optional ANY-VALUE)
(defalias 'macroexp--const-symbol-p #[513 "
\301>\206*\302!\206*\211\205*
>\206*\303!\205*\3041(
\211JL\210\3050\207\210\306\207" [byte-compile-const-variables (nil t) keywordp boundp (setting-constant) nil t] 4 (#$ . 14462)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put macroexp--const-symbol-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@73 Return non-nil if EXP will always evaluate to the same value.

(fn EXP)
(defalias 'macroexp-const-p #[257 "\211:\203\211@\301=\206K\211@\302=\205\211A@9\207\2119\203J\211\303
\304>\206I\305!\206I\211\205I
>\206I\306!\205I\3071G
\211JL\210\3030\207\210\310\207\310\207" [byte-compile-const-variables quote function nil (nil t) keywordp boundp (setting-constant) t] 5 (#$ . 15008)])
#@67 Return non-nil if EXP can be copied without extra cost.

(fn EXP)
(defalias 'macroexp-copyable-p #[257 "\2119\206\300
!\207" [macroexp-const-p] 3 (#$ . 15410)])
#@138 Return an expression E such that `(eval E)' is V.

E is either V or (quote V) depending on whether V evaluates to
itself or not.

(fn V)
(defalias 'macroexp-quote #[257 "\211:\204\300
!\204\2119\203\211\301>\203\207\302
D\207" [keywordp (nil t) quote] 3 (#$ . 15580)])
#@860 Return those of the BINDINGS which might be used in SEXP.
It is used as a poor-man's "free variables" test.  It differs from a true
test of free variables in the following ways:
- It does not distinguish variables from functions, so it can be used
  both to detect whether a given variable is used by SEXP and to
  detect whether a given function is used by SEXP.
- It does not actually know ELisp syntax, so it only looks for the presence
  of symbols in SEXP and can't distinguish if those symbols are truly
  references to the given variable (or function).  That can make the result
  include bindings which actually aren't used.
- For the same reason it may cause the result to fail to include bindings
  which will be used if SEXP is not yet fully macro-expanded and the
  use of the binding will only be revealed by macro expansion.

(fn BINDINGS SEXP)
(defalias 'macroexp--fgrep #[514 "\300\301\302\303\"CC\211\203\230\203\230\211
A\262\242\304
\"\204\224\305
\306#\210\307
!\203/\310\311\"\262
\211\306\203\222:\203C\211A\262\242\202G\300\262
\203Q\300\262\202dA\262=\203a\300\262\202d\306\262\211:\204o\307
!\203x\211B\262\210\2021\211	\236\211\203\215\211B\262\312
\"\262\n\266\2021\266\210\202\207" [nil make-hash-table :test eq gethash puthash t vectorp mapcar identity remove] 13 (#$ . 15864)])
#@55 Return the Elisp backtrace, more recent frames first.
(defalias 'macroexp--backtrace #[0 "\300\301\302
!\211\205\211B\262
T\211\262\262
\204
\237\207" [nil 0 backtrace-frame] 5 (#$ . 17226)])
#@14 

(fn FRAME)
(defalias 'macroexp--trim-backtrace-frame #[257 "\211:\205\216\211\243\211:\205\214\211\242\211\300\267\202\211
\243\211:\205-\211\242\211:\205+\211\242\301
\302BD\262
\262
\262
\202\212
\243\211:\205o\211\242\211:\205m\211\242
\243\211:\205k\211\242\2119\204^\211\242\303=\203h\211A@9\203h\304\305BBD\202i\306\262
\266\202\262
\262
\202\212
\243\211:\205\204\211\242\307\310!D\262
\262
\202\212\311\262
\262
\207" [#s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (macroexpand 20 internal-macroexpand-for-load 50 load-with-code-conversion 116)) macroexpand (…) quote macroexpand-all (…) (macroexpand-all …) load file-name-nondirectory nil] 12 (#$ . 17431)])
#@60 Stack of files currently undergoing eager macro-expansion.
(defvar macroexp--pending-eager-loads nil (#$ . 18170))
(defvar macroexp--debug-eager nil)
#@20 

(fn FORM FULL-P)
(defalias 'internal-macroexpand-for-load #[514 "@\303=\203	
\207	\203W	\235\203W\304\305\306\307\310 \"\"\311\312	!D\211
\235A\235\211\203/\211\313C\241\210@\242\314=\203;A\262\n\203F\315\316!\210\202Q\317\320\321\322\237\323#\"\210\303B\207\3241o	B\211\203i\314!\202l\325!)0\207\317\326\"\210\207" [macroexp--pending-eager-loads load-file-name macroexp--debug-eager skip delq nil mapcar macroexp--trim-backtrace-frame macroexp--backtrace load file-name-nondirectory … macroexpand-all debug eager-macroexp-cycle message "Warning: Eager macro-expansion skipped due to cycle:\n  %s" mapconcat prin1-to-string " => " (error) macroexpand "Eager macro-expansion failure: %S"] 11 (#$ . 18326)])
(provide 'macroexp)