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



(byte-code "\301\302!B\301\207" [package--builtin-versions purecopy (nadvice 1 0)] 2)
#@288 List of descriptions of how to add a function.
Each element has the form (WHERE BYTECODE STACK) where:
  WHERE is a keyword indicating where the function is added.
  BYTECODE is the corresponding byte-code that will be used.
  STACK is the amount of stack space needed by the byte-code.
(defvar advice--where-alist '((:around "\300\301\302#\207" 5) (:before "\300\301\"\210\300\302\"\207" 4) (:after "\300\302\"\300\301\"\210\207" 5) (:override "\300\301\"\207" 4) (:after-until "\300\302\"\206\300\301\"\207" 4) (:after-while "\300\302\"\205\300\301\"\207" 4) (:before-until "\300\301\"\206\300\302\"\207" 4) (:before-while "\300\301\"\205\300\302\"\207" 4) (:filter-args "\300\302\301!\"\207" 5) (:filter-return "\301\300\302\"!\207" 5)) (#$ . 173))
(defvar advice--bytecodes (mapcar 'cadr advice--where-alist))
#@15 

(fn OBJECT)
(defalias 'advice--p #[257 "\301
!\205$\211\302H\303=\205$\211G\304>\205$\211\305H>\205$\211\306H\302H\307=\207" [advice--bytecodes byte-code-function-p 0 128 (5 6) 1 2 apply] 3 (#$ . 1017)])
#@10 

(fn F)
(defalias 'advice--car #[257 "\211\300H\301H\207" [2 1] 3 (#$ . 1234)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put advice--car speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@10 

(fn F)
(defalias 'advice--cdr #[257 "\211\300H\300H\207" [2] 3 (#$ . 1458)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put advice--cdr speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@10 

(fn F)
(defalias 'advice--props #[257 "\211\300H\301H\207" [2 3] 3 (#$ . 1680)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put advice--props speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@10 

(fn F)
(defalias 'advice--cd*r #[257 "\300
!\203\211\211\301H\301H\262
\262
\202\207" [advice--p 2] 4 (#$ . 1908)])
#@10 

(fn F)
(defalias 'advice--where #[257 "\211\301H\302\211\203\211@
A@=\203\211@\262
A\266\202\202\210\207" [advice--where-alist 1 nil] 7 (#$ . 2036)])
#@30 

(fn FLIST FUNCTION MACROP)
(defalias 'advice--make-single-doc #[771 "\300!\301\302\203
\303\202\304#\211\305H\306H\262
\2119\203$\307\310\"\202c\311\211\305H\312H\262
\236A\313\314\"\315
\"\211\203A\211A\262\203\\
\203S\301\316#\266\203\202c\301\317\"\266\203\202c
\206a\320\266\203\262
\321Q\207" [advice--where format "This %s has %s advice: " "macro" "function" 2 1 format-message "`%S'." name 3 documentation t help-split-fundoc "%s\n%s" "%s" "No documentation" "\n"] 13 (#$ . 2203)])
#@74 Build the raw docstring for FUNCTION, presumably advised.

(fn FUNCTION)
(defalias 'advice--make-docstring #[257 "\300
!\301
\242\302=\301
\203A\262\211\242\303=\262
\203.\304N\203.\305\304N#\262
\202U\306!\203U\307H\250\203>\262\211\305#P\262
\211\310H\310H\262
\262\202.\204\\\262=?\205g\311\312\"\313
\"\211\204\207\314!\211;\203}\312\202\202\315\"\262
\202\215\211A\262\211@\262
\316\317\320\"\203\234\320\202\235\321Q\"\207" [indirect-function nil macro autoload advice--pending advice--make-single-doc advice--p 4 2 documentation t help-split-fundoc help-function-arglist help--make-usage-docstring help-add-fundoc-usage string-suffix-p "\n" "\n\n"] 12 (#$ . 2726)])
#@48 Evaluate the interactive spec SPEC.

(fn SPEC)
(defalias 'advice-eval-interactive-spec #[257 "\211;\203\300\301\302\303D\304BBB!\207\305
!\207" [call-interactively lambda (&rest args) interactive (args) eval] 6 (#$ . 3457)])
#@82 Like `interactive-form' but tries to avoid autoloading functions.

(fn FUNCTION)
(defalias 'advice--interactive-form #[257 "\300
!\205&\2119\203\301
!\211\242\302=\262
\204\303
!\207\304\305\306\303\307DDDDD\207" [commandp indirect-function autoload interactive-form interactive advice-eval-interactive-spec cadr quote] 7 (#$ . 3691)])
#@22 

(fn FUNCTION MAIN)
(defalias 'advice--make-interactive-form #[514 "\300!\300!
A@\211\242\301=\203\211A@\262
\302
!\203&\303\304D\304A@DE\207\206+
A@\207" [advice--interactive-form function functionp funcall quote] 9 (#$ . 4039)])
#@100 Build a function value that adds FUNCTION to MAIN.

(fn BYTE-CODE STACK-DEPTH FUNCTION MAIN PROPS)
(defalias 'advice--make-1 #[1285 "\301\"\302\303\304\305\302			$	\306\307!\204#\307\n!\205*\310\"C&
\2036\311
#\210\207" [advertised-signature-table gethash apply make-byte-code 128 vector nil commandp advice--make-interactive-form puthash] 16 (#$ . 4287)])
#@156 Build a function value that adds FUNCTION to MAIN at WHERE.
WHERE is a symbol to select an entry in `advice--where-alist'.

(fn WHERE FUNCTION MAIN PROPS)
(defalias 'advice--make #[1028 "\301
\236A\206\302\303!\205\301\211\304H\305H\262
\236A\206\302\211\203U

V\203U\306\211\304H\304H\262
$\307\310H\305H\211\304H\310H\262
	\211\304H\305H\262
%\207\236\211\204b\311\312\"\210\307
A@\3048%\207" [advice--where-alist depth 0 advice--p 2 3 advice--make advice--make-1 1 error "Unknown add-function location `%S'"] 15 (#$ . 4672)])
#@37 

(fn FUNCTION USE-NAME DEFINITION)
(defalias 'advice--member-p #[771 "\300\211\204`\301!\203`\302=\203.\303\211\304H\305H\262
\236A\232\204M\211\304H\306H\262
\232\202J\203A\303\211\304H\305H\262
\236A\202I\211\304H\306H\262
\232\203S
\262
\202

\211\304H\304H\262
\262\202
\207" [nil advice--p :use-both name 2 3 1] 9 (#$ . 5244)])
#@22 

(fn FLIST TWEAKER)
(defalias 'advice--tweak #[514 "\300!\204\f\211\301\301#\207
\211\302H\303H\262
\211\302H\302H\262
\211\302H\304H\262
#\211\2030\211@\207\305\"
=\203>\207\306\303H\304H%\207" [advice--p nil 2 1 3 advice--tweak advice--make-1] 13 (#$ . 5605)])
#@23 

(fn FLIST FUNCTION)
(defalias 'advice--remove-function #[514 "\300\301\302\"\"\207" [advice--tweak make-closure #[771 "\204
\207\300\232\204\300\301\236A\232\205\302\300\"C\207" [V0 name advice--remove-function] 6 "\n\n(fn FIRST REST PROPS)"]] 7 (#$ . 5901)])
#@293 Keeps an example of the special "run the default value" functions.
These functions play the same role as t in buffer-local hooks, and to recognize
them, we keep a sample here against which to compare.  Each instance is
different, but `function-equal' will hopefully ignore those differences.
(defvar advice--buffer-local-function-sample nil (#$ . 6182))
#@16 

(fn VAR VAL)
(defalias 'advice--set-buffer-local #[514 "\301
\"\203\302!\207\303!
L\207" [advice--buffer-local-function-sample function-equal kill-local-variable make-local-variable] 5 (#$ . 6542)])
#@70 Buffer-local value of VAR, presumed to contain a function.

(fn VAR)
(defalias 'advice--buffer-local #[257 "\301
!\203	\211J\207\302\303\"\211\207" [advice--buffer-local-function-sample local-variable-p make-closure #[128 "\301\302\300!\"\207" [V0 apply default-value] 4 "\n\n(fn &rest ARGS)"]] 4 (#$ . 6754)])
(byte-code "\300\301\302\303#\300\207" [function-put advice--buffer-local gv-expander #[385 "\300\301\302$\207" [gv--defsetter advice--buffer-local #[385 "\300\301C\"B\207" [advice--set-buffer-local append] 6 "\n\n(fn VAL &rest ARGS)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@14 

(fn PLACE)
(defalias 'advice--normalize-place #[257 "\211\242\300=\203\f\301
AB\207\211\242\302=\203\211A@\207\2119\203\"\303\304DD\207\207" [local advice--buffer-local var default-value quote] 4 (#$ . 7348)])
#@2360 Add a piece of advice on the function stored at PLACE.
FUNCTION describes the code to add.  WHERE describes where to add it.
WHERE can be explained by showing the resulting new function, as the
result of combining FUNCTION and the previous value of PLACE, which we
call OLDFUN here:
`:before'	(lambda (&rest r) (apply FUNCTION r) (apply OLDFUN r))
`:after'	(lambda (&rest r) (prog1 (apply OLDFUN r) (apply FUNCTION r)))
`:around'	(lambda (&rest r) (apply FUNCTION OLDFUN r))
`:override'	(lambda (&rest r) (apply FUNCTION r))
`:before-while'	(lambda (&rest r) (and (apply FUNCTION r) (apply OLDFUN r)))
`:before-until'	(lambda (&rest r) (or  (apply FUNCTION r) (apply OLDFUN r)))
`:after-while'	(lambda (&rest r) (and (apply OLDFUN r) (apply FUNCTION r)))
`:after-until'	(lambda (&rest r) (or  (apply OLDFUN r) (apply FUNCTION r)))
`:filter-args'	(lambda (&rest r) (apply OLDFUN (funcall FUNCTION r)))
`:filter-return'(lambda (&rest r) (funcall FUNCTION (apply OLDFUN r)))
If FUNCTION was already added, do nothing.
PROPS is an alist of additional properties, among which the following have
a special meaning:
- `name': a string or symbol.  It can be used to refer to this piece of advice.
- `depth': a number indicating a preference w.r.t ordering.
  The default depth is 0.  By convention, a depth of 100 means that
  the advice  should be innermost (i.e. at the end of the list),
  whereas a depth of -100 means that the advice should be outermost.

If PLACE is a symbol, its `default-value' will be affected.
Use (local \='SYMBOL) if you want to apply FUNCTION to SYMBOL buffer-locally.
Use (var VAR) if you want to apply FUNCTION to the (lexical) VAR.
If you are trying to modify an existing named function rather
than a function value, you probably want to use `advice-add'
instead (see Info node `(elisp) Advising Named Functions').

If one of FUNCTION or OLDFUN is interactive, then the resulting function
is also interactive.  There are 3 cases:
- FUNCTION is not interactive: the interactive spec of OLDFUN is used.
- The interactive spec of FUNCTION is itself a function: it should take one
  argument (the interactive spec of OLDFUN, which it can pass to
  `advice-eval-interactive-spec') and return the list of arguments to use.
- Else, use the interactive spec of FUNCTION and ignore the one of OLDFUN.

(fn WHERE PLACE FUNCTION &optional PROPS)
(defalias 'add-function '(macro . #[1027 "\300\301\302!D\257\207" [advice--add-function gv-ref advice--normalize-place] 9 (#$ . 7573)]))
(put 'add-function 'edebug-form-spec '(form [&or symbolp ("local" form) ("var" sexp) gv-place] form &optional form))
#@33 

(fn WHERE REF FUNCTION PROPS)
(defalias 'advice--add-function #[1028 "\300\301!\2034\211@ \262
\302
!\205\303
!?\262
\2034\304\305\211@ \262
!!\211\306>\2043\307\310!\210\311
!\210\210\312
\236A\313
\206>\205C\314\211@ \262
#\211\203hA\315\211@ \262
\206e\211\316H\317H\262
\"!\210A\320\211@ \262
$!\207" [featurep native-compile subrp subr-native-elisp-p intern subr-name (macroexpand rename-buffer) require comp comp-subr-trampoline-install name advice--member-p t advice--remove-function 2 1 advice--make] 12 (#$ . 10198)])
#@215 Remove the FUNCTION piece of advice from PLACE.
If FUNCTION was not added to PLACE, do nothing.
Instead of FUNCTION being the actual function, it can also be the `name'
of the piece of advice.

(fn PLACE FUNCTION)
(defalias 'remove-function '(macro . #[514 "\300\301!\302\303\"\"\207" [gv-get advice--normalize-place make-closure #[514 "\301\300E\302
!\203\211\202\303\304!\305\306E!E
=\203\"\207\307DC\"\207" [V0 advice--remove-function macroexp-const-p make-symbol "new" unless eq macroexp-let*] 8 "\n\n(fn GETTER SETTER)"]] 7 (#$ . 10763)]))
(put 'remove-function 'edebug-form-spec '([&or symbolp ("local" form) ("var" sexp) gv-place] form))
#@196 Apply F to every advice function in FUNCTION-DEF.
F is called with two arguments: the function that was added, and the
properties alist that was specified when it was added.

(fn F FUNCTION-DEF)
(defalias 'advice-function-mapc #[514 "\300
!\205&

\211\301H\302H\262
\211\301H\303H\262
\"\210\211\211\301H\301H\262
\262
\202\207" [advice--p 2 1 3] 7 (#$ . 11432)])
#@175 Return non-nil if ADVICE is already in FUNCTION-DEF.
Instead of ADVICE being the actual function, it can also be the `name'
of the piece of advice.

(fn ADVICE FUNCTION-DEF)
(defalias 'advice-function-member-p #[514 "\300\301#\207" [advice--member-p :use-both] 6 (#$ . 11807)])
#@16 

(fn OLD NEW)
(defalias 'advice--subst-main #[514 "\300\301\302\"\"\207" [advice--tweak make-closure #[771 "?\205\300\207" [V0] 4 "\n\n(fn FIRST REST PROPS)"]] 7 (#$ . 12093)])
#@19 

(fn SYMBOL DEF)
(defalias 'advice--normalize #[514 "\300
!\203\301\302\"\207\2119\203&\303
!\203&\304\305\306\"B\307\310AB#\210\207\211\242\304=\203E\3111;\211
A\241\210\3120\202=\210\313\204E\304
AB\207\207" [special-form-p error "Advice impossible: %S is a special form" macrop macro make-closure #[128 "\301\300B!\207" [V0 macroexpand] 4 "\n\n(fn &rest R)"] put advice--saved-rewrite (error) t nil] 8 (#$ . 12282)])
#@10 

(fn X)
(defalias 'advice--strip-macro #[257 "\211\242\300=\203\n\211A\207\207" [macro] 3 (#$ . 12723)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put advice--strip-macro speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@15 

(fn SYMBOL)
(defalias 'advice--symbol-function #[257 "\211\300N\206\211K\211\242\301=\203\211A\262
\207" [advice--pending macro] 4 (#$ . 12981)])
#@30 

(fn FSETFUN SYMBOL NEWDEF)
(defalias 'advice--defalias-fset #[771 "\204\300\262\301
!\203\302
!\262
\202+\211\242\303=\203+\301
A!\203+\303\302A!B\262

\304N\2037\305\304\306#\210\307\"\262
\310!
\203v
\211\242\311=\262
\204v
\211\242\303=\203Z\211A\262
\312\"\305\313\306#\210=\203q\202t\303B\"\207\211\313N=\204\207\305\313\312\306\"#\210\"\207" [fset advice--p advice--cd*r macro advice--saved-rewrite put nil advice--normalize advice--symbol-function autoload advice--subst-main advice--pending] 10 (#$ . 13139)])
#@220 Like `add-function' but for the function named SYMBOL.
Contrary to `add-function', this will properly handle the cases where SYMBOL
is defined as a macro, alias, command, ...

(fn SYMBOL WHERE FUNCTION &optional PROPS)
(defalias 'advice-add #[1027 "K\300\"

=\204
M\210\301\242\302=\203(\303\304\"\303\305\"B\262
\202S\2036\211\242\306=\262
\203F\303\307\"\303\310\"B\262
\202S\303\311\"\303\312\"B\262
\303\313\"\303\314\"B\262
$\210\315\316\317\320\nDD#\210\301\321\303\322\"\303\323\"B\262
\324\325$\266\325\207" [advice--normalize advice--add-function macro make-closure #[0 "\300A\207" [V0] 1] #[257 "\300
\241\207" [V0] 3 "\n\n(fn V1157)"] autoload #[0 "\300\301N\207" [V0 advice--pending] 2] #[257 "\301\300\302#\207" [V0 put advice--pending] 5 "\n\n(fn V1157)"] #[0 "\300K\207" [V0] 1] #[257 "\300
M\207" [V0] 3 "\n\n(fn V1157)"] #[0 "\300@ \207" [V0] 1] #[257 "\300A
!\207" [V0] 3 "\n\n(fn GV--VAL)"] put function-documentation advice--make-docstring quote :around #[0 "\300\301N\207" [V0 defalias-fset-function] 2] #[257 "\301\300\302#\207" [V0 put defalias-fset-function] 5 "\n\n(fn GV--VAL)"] advice--defalias-fset nil] 13 (#$ . 13703)])
#@292 Like `remove-function' but for the function named SYMBOL.
Contrary to `remove-function', this also works when SYMBOL is a macro
or an autoload and it preserves `fboundp'.
Instead of the actual function to remove, FUNCTION can also be the `name'
of the piece of advice.

(fn SYMBOL FUNCTION)
(defalias 'advice-remove #[514 "
K\300N\203\301\302\"\301\303\"B\262
\2029\211\242\304=\203-\211\301\305\"\301\306\"B\262
\2029\301\307\"\301\310\"B\262
\311
@ \"\211@ =\204L
A
!\210\266\312\313!!\204\203\311\314N\315\"\211\314N=\204j\316\314#\210\210\317N\211\203\202K\243
A=\203\202\211\317N@M\210\210\210\320\207" [advice--pending make-closure #[0 "\300\301N\207" [V0 advice--pending] 2] #[257 "\301\300\302#\207" [V0 put advice--pending] 5 "\n\n(fn V1158)"] macro #[0 "\300A\207" [V0] 1] #[257 "\300
\241\207" [V0] 3 "\n\n(fn V1158)"] #[0 "\300K\207" [V0] 1] #[257 "\300
M\207" [V0] 3 "\n\n(fn V1158)"] advice--remove-function advice--p advice--symbol-function defalias-fset-function advice--defalias-fset put advice--saved-rewrite nil] 8 (#$ . 14902)])
#@273 Define an advice and add it to function named SYMBOL.
See `advice-add' and `add-function' for explanation on the
arguments.  Note if NAME is nil the advice is anonymous;
otherwise it is named `SYMBOL@NAME'.

(fn SYMBOL (WHERE LAMBDA-LIST &optional NAME DEPTH) &rest BODY)
(defalias 'define-advice '(macro . #[642 "
<\204\f\300\301\302D\"\210\303\304G\305#\204\300\306\304\305GE\"\210
@A@\3048\3078\211\2051\310
BC\204>\311BB\202X;\204H9\203T\312\313\314\n#!\202X\315\316\"\317\3209\205i\321BBBC\322\323
D\n\324D\205~\323	DCBBBBC\"B\207" [signal wrong-type-argument listp <= 2 4 wrong-number-of-arguments 3 depth lambda intern format "%s@%s" error "Unrecognized name spec `%S'" prog1 append defun advice-add quote function] 18 (#$ . 15989)]))
(byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put define-advice lisp-indent-function 2 doc-string-elt 3 put edebug-form-spec (sexp sexp def-body)] 6)
#@192 Apply FUN to every advice function in SYMBOL.
FUN is called with a two arguments: the function that was added, and the
properties alist that was specified when it was added.

(fn FUN SYMBOL)
(defalias 'advice-mapc #[514 "\300\301!\"\207" [advice-function-mapc advice--symbol-function] 6 (#$ . 16961)])
#@167 Return non-nil if ADVICE has been added to SYMBOL.
Instead of ADVICE being the actual function, it can also be the `name'
of the piece of advice.

(fn ADVICE SYMBOL)
(defalias 'advice-member-p #[514 "\300\301!\"\207" [advice-function-member-p advice--symbol-function] 6 (#$ . 17272)])
(add-hook 'called-interactively-p-functions 'advice--called-interactively-skip)
#@28 

(fn ORIGI FRAME1 FRAME2)
(defalias 'advice--called-interactively-skip #[771 "
C
CC\300\242A@\301=\205\213\211#\210\302\303\242A@!!\205\213\211#\210\302\242A@!\203\205\242A@\242A@\301=\203X
#\210\302\303\242A@!!\203X
#\266\202'
#\210\242\203u\242A@\301=\203X\304\2428
=\203X
#\210
#\266\202'
\242ZS\207" [#[771 "\242\240\210
\300\242\301\"\240\210\211
\242T\240\207" [backtrace-frame called-interactively-p] 7 "\n\n(fn FRAME1 FRAME2 I)"] apply advice--p indirect-function 3] 12 (#$ . 17645)])
(provide 'nadvice)