;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:01 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/edebug.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

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

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

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


(byte-code "\300\301!\210\302\303\304\305\306\307%\210\310\311\312\313\314DD\315\316\317\306\303&\210\310\320\312\313\321DD\322\316\323\306\303&\210\310\324\312\313\325DD\326\316\323\306\303&\210\310\327\312\313\330DD\331\316\323\306\303&\210\310\332\312\313\333DD\334\316\335\306\303&\210\310\336\312\313\337DD\340\316\323\306\303&\210\310\341\312\313\342DD\343\316\344\306\303&\210\310\345\312\313\346DD\347\316\323\306\303&\210\310\350\312\313\351DD\352\316\323\306\303&\210\310\353\312\313\354DD\355\316\323\306\303&\210\310\356\312\313\357DD\360\316\361\306\303&\210\310\362\312\313\363DD\364\316\361\306\303&\210\310\365\312\313\366DD\367\316\323\306\303&\210\310\370\312\313\371DD\372\316\323\306\303&\210\310\373\312\313\374DD\375\316\376\306\303&\210\310\377\312\313\201@DD\201A\316\323\306\303&\210\310\201B\312\313\201CDD\201D\316\201E\306\303&\210\310\201F\312\313\201GDD\201H\316\201I\306\303&\207" [require macroexp custom-declare-group edebug nil "A source-level debugger for Emacs Lisp." :group lisp custom-declare-variable edebug-setup-hook funcall function #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Functions to call before edebug is used.\nEach time it is set to a new value, Edebug will call those functions\nonce and then reset `edebug-setup-hook' to nil.  You could use this\nto load up Edebug specifications associated with a package you are\nusing, but only when you also use Edebug." :type hook edebug-all-defs #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If non-nil, evaluating defining forms instruments for Edebug.\nThis applies to `eval-defun', `eval-region', `eval-buffer', and\n`eval-current-buffer'.  `eval-region' is also called by\n`eval-last-sexp', and `eval-print-last-sexp'.\n\nYou can use the command `edebug-all-defs' to toggle the value of this\nvariable.  You may wish to make it local to each buffer with\n(make-local-variable 'edebug-all-defs) in your\n`emacs-lisp-mode-hook'." boolean edebug-all-forms #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil means evaluation of all forms will instrument for Edebug.\nThis doesn't apply to loading or evaluations in the minibuffer.\nUse the command `edebug-all-forms' to toggle the value of this option." edebug-eval-macro-args #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil means all macro call arguments may be evaluated.\nIf this variable is nil, the default, Edebug will *not* wrap\nmacro call arguments as if they will be evaluated.\nFor each macro, an `edebug-form-spec' overrides this option.\nSo to specify exceptions for macros that have some arguments evaluated\nand some not, use `def-edebug-spec' to specify an `edebug-form-spec'." edebug-save-windows #[0 "\300\207" [t] 1 "\n\n(fn)"] "If non-nil, Edebug saves and restores the window configuration.\nThat takes some time, so if your program does not care what happens to\nthe window configurations, it is better to set this variable to nil.\n\nIf the value is a list, only the listed windows are saved and\nrestored.\n\n`edebug-toggle-save-windows' may be used to change this variable." (choice boolean (repeat string)) edebug-save-displayed-buffer-points #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If non-nil, save and restore point in all displayed buffers.\n\nSaving and restoring point in other buffers is necessary if you are\ndebugging code that changes the point of a buffer that is displayed\nin a non-selected window.  If Edebug or the user then selects the\nwindow, the buffer's point will be changed to the window's point.\n\nSaving and restoring point in all buffers is expensive, since it\nrequires selecting each window twice, so enable this only if you\nneed it." edebug-initial-mode #[0 "\300\207" [step] 1 "\n\n(fn)"] "Initial execution mode for Edebug, if non-nil.\nIf this variable is non-nil, it specifies the initial execution mode\nfor Edebug when it is first activated.  Possible values are step, next,\ngo, Go-nonstop, trace, Trace-fast, continue, and Continue-fast." (choice (const step) (const next) (const go) (const Go-nonstop) (const trace) (const Trace-fast) (const continue) (const Continue-fast)) edebug-trace #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil means display a trace of function entry and exit.\nTracing output is displayed in a buffer named `*edebug-trace*', one\nfunction entry or exit per line, indented by the recursion level.\n\nYou can customize by replacing functions `edebug-print-trace-before'\nand `edebug-print-trace-after'." edebug-test-coverage #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If non-nil, Edebug tests coverage of all expressions debugged.\nThis is done by comparing the result of each expression with the\nprevious result.  Coverage is considered OK if two different\nresults are found.\n\nUse `edebug-display-freq-count' to display the frequency count and\ncoverage information for a definition." edebug-continue-kbd-macro #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If non-nil, continue defining or executing any keyboard macro.\nUse this with caution since it is not debugged." edebug-print-length #[0 "\300\207" [50] 1 "\n\n(fn)"] "If non-nil, default value of `print-length' for printing results in Edebug." integer edebug-print-level #[0 "\300\207" [50] 1 "\n\n(fn)"] "If non-nil, default value of `print-level' for printing results in Edebug." edebug-print-circle #[0 "\300\207" [t] 1 "\n\n(fn)"] "If non-nil, default value of `print-circle' for printing results in Edebug." edebug-unwrap-results #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil if Edebug should unwrap results of expressions.\nThat is, Edebug will try to remove its own instrumentation from the result.\nThis is useful when debugging macros where the results of expressions\nare instrumented expressions.  But don't do this when results might be\ncircular or an infinite loop will result." edebug-on-error #[0 "\300\207" [t] 1 "\n\n(fn)"] "Value bound to `debug-on-error' while Edebug is active.\n\nIf `debug-on-error' is non-nil, that value is still used.\n\nIf the value is a list of signal names, Edebug will stop when any of\nthese errors are signaled from Lisp code whether or not the signal is\nhandled by a `condition-case'.  This option is useful for debugging\nsignals that *are* handled since they would otherwise be missed.\nAfter execution is resumed, the error is signaled again." (choice (const :tag "off") (repeat :menu-tag "When" :value (nil) (symbol :format "%v")) (const :tag "always" t)) edebug-on-quit #[0 "\300\207" [t] 1 "\n\n(fn)"] "Value bound to `debug-on-quit' while Edebug is active." edebug-global-break-condition #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If non-nil, an expression to test for at every stop point.\nIf the result is non-nil, then break.  Errors are ignored." sexp edebug-sit-for-seconds #[0 "\300\207" [1] 1 "\n\n(fn)"] "Number of seconds to pause when execution mode is `trace' or `continue'." number] 8)
(defalias 'get-edebug-spec #[257 "\300
\2119\203\301
\302\303#\211\262\203\211\262\202
\207" [nil function-get edebug-form-spec macro] 7 "\n\n(fn SYMBOL)"])
#@156 Return t if SPEC uses only extant spec symbols.
An extant spec symbol is a symbol that is not a function and has a
`edebug-form-spec' property.

(fn SPEC)
(defalias 'edebug-basic-spec #[257 "\211C\211@<\203\300\301\302\303\304\305\306!\307\"\310\311%D\215\202/\211@9\205/\312
@!?\205/\313
@\314\"\207" [basic funcall make-byte-code 0 "\300@\203\301\300@@!\204\302\303\304\"\210\300\211@A\240\210\202\305\207" vconcat vector [edebug-basic-spec throw basic nil t] 3 "\n\n(fn)" functionp function-get edebug-form-spec] 10 (#$ . 7539)])
#@55 Integer used by `edebug-gensym' to produce new names.
(defvar edebug-gensym-index 0 (#$ . 8091))
#@230 Generate a fresh uninterned symbol.
There is an optional argument, PREFIX.  PREFIX is the string
that begins the new name.  Most people take just the default,
except when debugging needs suggest otherwise.

(fn &optional PREFIX)
(defalias 'edebug-gensym #[256 "\211\204\301\262
\302\303
\204%\304!P\262
T\305
!\204	\306
!\262\202	
\207" [edebug-gensym-index "G" nil "" int-to-string intern-soft make-symbol] 6 (#$ . 8195)])
#@115 Return t if OBJECT is a lambda list keyword.
A lambda list keyword is a symbol that starts with `&'.

(fn OBJECT)
(defalias 'edebug-lambda-list-keywordp #[257 "\2119\205\f\300
!\301H\302U\207" [symbol-name 0 38] 3 (#$ . 8636)])
(defalias 'edebug-last-sexp #[0 "\300\212\301\302!\210`)`{!@\207" [read-from-string forward-sexp -1] 3 "\n\n(fn)"])
#@60 Return a list of windows, in order of `next-window'.

(fn)
(defalias 'edebug-window-list #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211@\237\207" [nil walk-windows make-byte-code 257 "\300
\300@B\240\207" vconcat vector [] 4 "\n\n(fn W)"] 8 (#$ . 8987)])
(defalias 'edebug-lookup-function #[257 "\2119\203\300
!\203\211K\262
\202\207" [fboundp] 3 "\n\n(fn OBJECT)"])
(put 'edebug-lookup-function 'byte-optimizer 'byte-compile-inline-expand)
#@77 Return the macro named by OBJECT, or nil if it is not a macro.

(fn OBJECT)
(defalias 'edebug-macrop #[257 "\211\2119\203\300
!\203\211K\262
\202
\262
\211<\205)\211@\301=\205)\302
A!\205)\211\207" [fboundp macro functionp] 4 (#$ . 9455)])
(defalias 'edebug-sort-alist #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [sort make-byte-code 514 "\300@@\"\207" vconcat vector [] 5 "\n\n(fn E1 E2)"] 10 "\n\n(fn ALIST FUNCTION)"])
#@42 Name of the buffer to put trace info in.
(defconst edebug-trace-buffer "*edebug-trace*" (#$ . 9907))
(defalias 'edebug-pop-to-buffer #[513 "\301
!\203\302
!=\203\211\202Q\302\303 !=\203 \303 \202Q\304\305\"\206Q\306\307!\2034\310\311 !\202Q\304!\312\313\314\305\315\316\317!\320\"\321\322%D\215\262
\206Q\310\311 !\262
\323
\"\210\324
!\210\325
\305\"\207" [edebug-trace-buffer edebug-window-live-p window-buffer selected-window get-buffer-window 0 one-window-p nomini split-window minibuffer-selected-window found funcall make-byte-code "\301\302\303\"\211\205)\211@\211\304 =\204\"\211\300=\204\"\305
!\204\"\306\307\"\210
A\266\202\202\207" vconcat vector [window-list nil nomini selected-window window-dedicated-p throw found] 5 "\n\n(fn)" set-window-buffer select-window set-window-hscroll] 11 "\n\n(fn BUFFER &optional WINDOW)"])
(defalias 'edebug-get-displayed-buffer-points #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211@\207" [nil walk-windows make-byte-code 257 "\211\301 =?\205\300\302!\303!B\300@B\240\207" vconcat vector [selected-window window-buffer window-point] 5 "\n\n(fn W)"] 8 "\n\n(fn)"])
(defalias 'edebug-set-buffer-points #[257 "r\300\301\")\207" [mapcar #[257 "\300
@!\205\211@q\210\211Ab\207" [buffer-live-p] 3 "\n\n(fn BUF-POINT)"]] 4 "\n\n(fn BUFFER-POINTS)"])
(defalias 'edebug-current-windows #[257 "\211<\203\n\300\301\"\207\302 \207" [mapcar #[257 "\300
!\205\211\301!\302!\303!\304!\257\207" [edebug-window-live-p window-buffer window-point window-start window-hscroll] 7 "\n\n(fn WINDOW)"] current-window-configuration] 4 "\n\n(fn WHICH-WINDOWS)"])
(defalias 'edebug-set-windows #[257 "\211<\203\n\300\301\"\207\302
!\207" [mapcar #[257 "\211\205\300\301\"\207" [apply #[1285 "\300!\205\301\"\210\302\"\210\303\"\210\304\"\207" [edebug-window-live-p set-window-buffer set-window-point set-window-start set-window-hscroll] 8 "\n\n(fn WINDOW BUFFER POINT START HSCROLL)"]] 4 "\n\n(fn ONE-WINDOW-INFO)"] set-window-configuration] 4 "\n\n(fn WINDOW-INFO)"])
(byte-code "\300\301\302\301!\203\f\301\202
\303K\"\207" [defalias edebug-original-read fboundp read] 4)
#@746 Read one Lisp expression as text from STREAM, return as Lisp object.
If STREAM is nil, use the value of `standard-input' (which see).
STREAM or the value of `standard-input' may be:
 a buffer (read from point and advance it)
 a marker (read from where it points and advance it)
 a function (call it with no arguments for each character,
     call it with a char as argument to push a char back)
 a string (takes text from string, starting at the beginning)
 t (read text line using minibuffer and use it).

This version, from Edebug, maybe instruments the expression.  But the
STREAM must be the current buffer to do so.  Whether it instruments is
also dependent on the values of `edebug-all-defs' and
`edebug-all-forms'.

(fn &optional STREAM)
(defalias 'edebug-read #[256 "\211\204\262
\211p=\203\301 \207\302
!\207" [standard-input edebug-read-and-maybe-wrap-form edebug-original-read] 3 (#$ . 12081)])
(byte-code "\300\301!\204\f\302\301\303K\"\210\300\207" [fboundp edebug-original-eval-defun defalias eval-defun] 3)
#@906 Evaluate the top-level form containing point, or after point.

If the current defun is actually a call to `defvar', then reset the
variable using its initial value expression even if the variable
already has some other value.  (Normally `defvar' does not change the
variable's value if it already has a value.)  Treat `defcustom'
similarly.  Reinitialize the face according to `defface' specification.

With a prefix argument, instrument the code for Edebug.

Setting `edebug-all-defs' to a non-nil value reverses the meaning of
the prefix argument.  Code is then instrumented when this function is
invoked without a prefix argument

If acting on a `defun' for FUNCTION, and the function was instrumented,
`Edebug: FUNCTION' is printed in the minibuffer.  If not instrumented,
just FUNCTION is printed.

If not acting on a `defun', the result of evaluation is displayed in
the minibuffer.

(fn EDEBUG-IT)
(defalias 'edebug-eval-defun #[257 "\211??=?\304
?=\305 *\211@\306=\203'\211\243\243\203'\307
A@!\210\202\216\211@\310=\203E\311
A@!\203E\312
A@\313\3148\n\"\"\210\202\216\211@\315=\203\216\316
A@\"\317
A@\320\304#\210\317
A@\321\3228#\210\323
\317\324A@D\325\324A@\326NDF\317\324A@D\327\3148FF\317A@\326\304#\210\262
\313\330!\n\"\262\204\240\331!\202\241
\207" [edebug-all-defs edebug-all-forms lexical-binding face-new-frame-defaults nil edebug-read-top-level-form defvar makunbound defcustom default-boundp set-default eval 2 defface assq-delete-all put face-defface-spec face-documentation 3 prog1 quote 'saved-face saved-face 'customized-face eval-sexp-add-defvars princ] 12 (#$ . 13116) "P"])
(defalias 'edebug-defun 'edebug-eval-top-level-form)
#@819 Evaluate the top level form point is in, stepping through with Edebug.
This is like `eval-defun' except that it steps the code for Edebug
before evaluating it.  It displays the value in the echo area
using `eval-expression' (which see).

If you do this on a function definition such as a defun or defmacro,
it defines the function and instruments its definition for Edebug,
so it will do Edebug stepping when called later.  It displays
`Edebug: FUNCTION' in the echo area to indicate that FUNCTION is now
instrumented for Edebug.

If the current defun is actually a call to `defvar' or `defcustom',
evaluating it this way resets the variable using its initial value
expression even if the variable already has some other value.
(Normally `defvar' and `defcustom' do not alter the value if there
already is one.)

(fn)
(defalias 'edebug-eval-top-level-form #[0 "\302\303\211\304\305 !*!\207" [edebug-all-defs edebug-all-forms eval-expression t eval-sexp-add-defvars edebug-read-top-level-form] 3 (#$ . 14810) nil])
(defalias 'edebug-read-top-level-form #[0 "`\300 \210\301 \210\302 
b\210\207" [end-of-defun beginning-of-defun edebug-read-and-maybe-wrap-form] 3 "\n\n(fn)"])
(defalias 'edebug-all-defuns 'edebug-all-defs)
#@45 Toggle edebugging of all definitions.

(fn)
(defalias 'edebug-all-defs #[0 "?\301\302\203
\303\202\304\"\207" [edebug-all-defs message "Edebugging all definitions is %s." "on" "off"] 3 (#$ . 16039) nil])
#@39 Toggle edebugging of all forms.

(fn)
(defalias 'edebug-all-forms #[0 "?\301\302\203
\303\202\304\"\207" [edebug-all-forms message "Edebugging all forms is %s." "on" "off"] 3 (#$ . 16255) nil])
(defalias 'edebug-install-read-eval-functions #[0 "?\205\301\302\303\304\"\207" [load-read-function edebug-read defalias eval-defun edebug-eval-defun] 3 "\n\n(fn)" nil])
(defalias 'edebug-uninstall-read-eval-functions #[0 "\301\302\303\304K\"\207" [load-read-function nil defalias eval-defun edebug-original-eval-defun] 3 "\n\n(fn)" nil])
#@481 A list of entries associating symbols with buffer regions.
Each entry is an `edebug--form-data' struct with fields:
SYMBOL, BEGIN-MARKER, and END-MARKER.  The markers
are at the beginning and end of an entry level form and SYMBOL is
a symbol that holds all edebug related information for the form on its
property list.

In the future (haha!), the symbol will be irrelevant and edebug data will
be stored in the definitions themselves rather than in the property
list of a symbol.
(defvar edebug-form-data nil (#$ . 16806))
(byte-code "\300\301!\210\302\303\304\305#\210\306\211\203\302\303\307\310\311!!#\210\207" [make-variable-buffer-local edebug-form-data put edebug--form-data-name compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-name (car cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/edebug.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'edebug--form-data-name #[257 "\211@\207" [] 2 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\207" [put edebug--form-data-begin compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-begin (nth 1 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/edebug.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'edebug--form-data-begin #[257 "\211A@\207" [] 2 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\207" [put edebug--form-data-end compiler-macro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-end (nth 2 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/edebug.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'edebug--form-data-end #[257 "\300
8\207" [2] 3 "\n\n(fn CL-X)"])
(byte-code "\300\301\302\303#\210\304\211\203\300\301\305\306\307!!#\210\207" [put edebug--make-form-data-entry compiler-macro #[1028 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (name begin end) (cl-block edebug--make-form-data-entry (list name begin end)) nil] 13 "\n\n(fn CL-WHOLE-ARG NAME BEGIN END)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/edebug.el" compiler-macro-file purecopy file-name-nondirectory] 7)
(defalias 'edebug--make-form-data-entry #[771 "E\207" [] 6 "\n\n(fn NAME BEGIN END)"])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\311#\210\302\313\314\315#\210\302\316\314\315#\210\302\317\314\315#\210\302\320\314\315#\207" [cl-struct-edebug--form-data-tags cl-struct-edebug--form-data put edebug--form-data cl-struct-slots ((name) (begin) (end)) cl-struct-type (list nil) cl-struct-include nil cl-struct-print edebug--make-form-data-entry side-effect-free t edebug--form-data-end edebug--form-data-begin edebug--form-data-name] 4)
(defalias 'edebug-set-form-data-entry #[1028 "\211\240\266A@\300\223\210\3018
\300\223\207" [nil 2] 7 "\n\n(fn ENTRY NAME BEGIN END)"])
(put 'edebug-set-form-data-entry 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-get-form-data-entry #[513 "\301\302\203H\303
W\203H@\211A@
ZA\262\303
X\203C\211W\203C\2034\3048U\203C\3048X\203C\211\262\262\266\202
\207" [edebug-form-data nil 999999 0 2] 11 "\n\n(fn PNT &optional END-POINT)"])
#@124 Return the edebug data symbol of the form where point is in.
If point is not inside a edebuggable form, cause error.

(fn)
(defalias 'edebug-form-data-symbol #[0 "\300`!\211@\262
\206
\301\302!\207" [edebug-get-form-data-entry error "Not inside instrumented form"] 2 (#$ . 20309)])
(defalias 'edebug-make-top-form-data-entry #[257 "\301
!\210\211B\211\207" [edebug-form-data edebug-clear-form-data-entry] 3 "\n\n(fn NEW-ENTRY)"])
#@124 If non-nil, clear ENTRY out of the form data.
Maybe clear the markers and delete the symbol's edebug property?

(fn ENTRY)
(defalias 'edebug-clear-form-data-entry #[257 "\211\205\n\301
\"\211\207" [edebug-form-data delq] 4 (#$ . 20749)])
(defalias 'edebug-syntax-error #[128 "\300\301\"\207" [signal invalid-read-syntax] 4 "\n\n(fn &rest ARGS)"])
(defconst edebug-read-syntax-table (byte-code "\300\301\302\"\303\211\304W\203

\305I\210\211T\262
\202
\306\307I\210
\310\311I\210
\312\313I\210
\314\315I\210
\316\317I\210
\320\321I\210
\322\323I\210
\324\325I\210
\326\327I\210
\330\331I\210
\332\333I\210
\207" [make-char-table syntax-table symbol 0 33 space 40 lparen 41 rparen 39 quote 96 backquote 44 comma 34 string 63 char 91 lbracket 93 rbracket 46 dot 35 hash] 5))
(defalias 'edebug-next-token-class #[0 "\301 \210g\302=\203%\212\303u\210gH\304=\203g\305U?\206g\306>)\203%\304\207gH\207" [edebug-read-syntax-table edebug-skip-whitespace 46 1 symbol 59 (44 46)] 2 "\n\n(fn)"])
(defalias 'edebug-skip-whitespace #[0 "\300\301w\210g\302U\205\303\301w\210\300\301w\210\202\207" [" 	
\n\f" nil 59 "^\n"] 2 "\n\n(fn)"])
(defalias 'edebug-read-sexp #[0 "\300 \211\301=\203\302p!\202G\211\303=\203\302p!\202G\211\304=\203*\305u\210\304\306 D\202G\211\307=\2037\310\306 D\202G\211\311=\203D\312\306 D\202G\302p!\207" [edebug-next-token-class symbol edebug-original-read string quote 1 edebug-read-sexp backquote \` comma \,] 3 "\n\n(fn)"])
(defvar edebug-offsets nil)
(defvar edebug-offsets-stack nil)
(defvar edebug-current-offset nil)
(defvar edebug-read-dotted-list nil)
(defalias 'edebug-initialize-offsets #[0 "\301\211\207" [edebug-current-offset nil] 2 "\n\n(fn)"])
(put 'edebug-initialize-offsets 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-store-before-offset #[257 "\211C\203
AB\241\210\202\211\304\211\211\nB\211\211\207" [edebug-current-offset edebug-offsets edebug-offsets-stack edebug-read-dotted-list nil] 6 "\n\n(fn POINT)"])
(defalias 'edebug-store-after-offset #[257 "\204
	\211A\237\241\210\202\303	\211AA\237	A@A\244\241\210	
\244\nA\211@\211\207" [edebug-read-dotted-list edebug-current-offset edebug-offsets-stack nil] 5 "\n\n(fn POINT)"])
(defalias 'edebug-ignore-offset #[0 "\211AA\241\207" [edebug-current-offset] 2 "\n\n(fn)"])
(defalias 'edebug-storing-offsets '(macro . #[385 "\300\301\302DBB\303BB\207" [unwind-protect progn edebug-store-before-offset ((edebug-store-after-offset (point)))] 6 "\n\n(fn POINT &rest BODY)"]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put edebug-storing-offsets edebug-form-spec (form body) lisp-indent-function 1] 4)
(defconst edebug-read-alist '((symbol . edebug-read-symbol) (lparen . edebug-read-list) (string . edebug-read-string) (quote . edebug-read-quote) (backquote . edebug-read-backquote) (comma . edebug-read-comma) (lbracket . edebug-read-vector) (hash . edebug-read-function)))
(defalias 'edebug-read-storing-offsets #[257 "\302\303\304DC\216\305`!\210\306 	\236A\206\307
!*\207" [edebug-read-dotted-list edebug-read-alist nil funcall #[0 "\300`!\207" [edebug-store-after-offset] 2 "\n\n(fn)"] edebug-store-before-offset edebug-next-token-class edebug-original-read] 3 "\n\n(fn STREAM)"])
(defalias 'edebug-read-symbol #[257 "\300
!\207" [edebug-original-read] 3 "\n\n(fn STREAM)"])
(defalias 'edebug-read-string #[257 "\300
!\207" [edebug-original-read] 3 "\n\n(fn STREAM)"])
(defalias 'edebug-read-quote #[257 "\300u\210\301\302DC\216\303`S!\210)\304\305!D\207" [1 funcall #[0 "\300`!\207" [edebug-store-after-offset] 2 "\n\n(fn)"] edebug-store-before-offset quote edebug-read-storing-offsets] 4 "\n\n(fn STREAM)"])
(defalias 'edebug-read-backquote #[257 "\300u\210\301\302DC\216\303`S!\210)\304\305!D\207" [1 funcall #[0 "\300`!\207" [edebug-store-after-offset] 2 "\n\n(fn)"] edebug-store-before-offset \` edebug-read-storing-offsets] 4 "\n\n(fn STREAM)"])
(defalias 'edebug-read-comma #[257 "`\300u\210\301g\302=\203\303\262
\300u\210\202 g\304=\203 \305\262
\300u\210\306\307DC\216\310!\210)\211\311!D\262
\207" [1 \, 46 \,\. 64 \,@ funcall #[0 "\300`!\207" [edebug-store-after-offset] 2 "\n\n(fn)"] edebug-store-before-offset edebug-read-storing-offsets] 6 "\n\n(fn STREAM)"])
(defalias 'edebug-read-function #[257 "\300u\210g\301=\203\300u\210\302\303DC\216\304`\305Z!\210)\306\307!D\207g\310>\203+\311u\210\312
!\207\313\314!\207" [1 39 funcall #[0 "\300`!\207" [edebug-store-after-offset] 2 "\n\n(fn)"] edebug-store-before-offset 2 function edebug-read-storing-offsets (58 66 79 88 98 111 120 49 50 51 52 53 54 55 56 57 48) -1 edebug-original-read edebug-syntax-error "Bad char after #"] 4 "\n\n(fn STREAM)"])
(defalias 'edebug-read-list #[257 "\301u\210\302\303 \304>\204\305!
B\262
\202\211\237\262
\303 \306=\203<\302\301u\210\305!\262


\244\210\303 \307=\2048\310\311!\210\211<\210\211\262
\301u\210\207" [edebug-read-dotted-list 1 nil edebug-next-token-class (rparen dot) edebug-read-storing-offsets dot rparen edebug-syntax-error "Expected `)'"] 5 "\n\n(fn STREAM)"])
(defalias 'edebug-read-vector #[257 "\300u\210\301\302 \303=\204\304!
B\262
\202\305\306\237\"\262
\300u\210\207" [1 nil edebug-next-token-class rbracket edebug-read-storing-offsets apply vector] 5 "\n\n(fn STREAM)"])
(defvar edebug-dotted-spec nil)
(defalias 'edebug-new-cursor #[514 "\300!\203\f\301\302\"\262

B\207" [vectorp append nil] 5 "\n\n(fn EXPRESSIONS OFFSETS)"])
(defalias 'edebug-set-cursor #[771 "\240\210
\241\210\207" [] 5 "\n\n(fn CURSOR EXPRESSIONS OFFSETS)"])
(put 'edebug-set-cursor 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-copy-cursor #[257 "\211@
AB\207" [] 3 "\n\n(fn CURSOR)"])
(defalias 'edebug-cursor-expressions #[257 "\211@\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-cursor-expressions 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-cursor-offsets #[257 "\211A\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-cursor-offsets 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-empty-cursor #[257 "\211@?\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-empty-cursor 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-top-element #[257 "\211@@\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-top-element 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-top-element-required #[385 "\203	\301\302\"\210
\211@?\262
\203\303\301#\210
\211@@\207" [edebug-dotted-spec edebug-no-match "Dot expected." apply] 6 "\n\n(fn CURSOR &rest ERROR)"])
(defalias 'edebug-top-offset #[257 "\211A@\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-top-offset 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-move-cursor #[257 "\211\211@?\262
\203\300
\301\"\210\211
@A\240\210\211
AA\241\210\207" [edebug-no-match "Not enough arguments."] 4 "\n\n(fn CURSOR)"])
(defalias 'edebug-before-offset #[257 "\211\211A\262
\211:\203\211@@\202\211S\207" [] 3 "\n\n(fn CURSOR)"])
(defalias 'edebug-after-offset #[257 "\211\211A@\262
\211:\203\211A\262
\202\211\207" [] 3 "\n\n(fn CURSOR)"])
(defvar edebug-gate nil)
(defvar edebug-def-name nil)
(defvar edebug-old-def-name nil)
(defvar edebug-error-point nil)
(defvar edebug-best-error nil)
(defalias 'edebug-read-and-maybe-wrap-form #[0 "\306\307
!\203\211 \210\202\310\311\"\210\210\306C\306\211\211\211\211\211\211\211\312	\\\313\n\\
\306\262\306\262\306\262\306\262\306\262\306\262\306\262\314\311\315\316\317\320\321!\322\"\323\324%D\215\262
\211\203l\325\326\"\210@.	\207" [edebug-setup-hook max-lisp-eval-depth max-specpdl-size edebug-error-point edebug-best-error edebug-gate nil functionp mapc funcall 800 2000 no-match make-byte-code 0 "\300\301 \240\210\302\207" vconcat vector [edebug-read-and-maybe-wrap-form1 nil] 2 "\n\n(fn)" apply edebug-syntax-error edebug-&rest edebug-&optional edebug-def-name edebug-top-window-data] 17 "\n\n(fn)"])
(defalias 'edebug-read-and-maybe-wrap-form1 #[0 "\305\211\211\211\211\211\211\212\306 \307=\203N\310u\210\306 \311=\203N\312p!\2629\205)\313!\262<\2054@\314=\262
\205LA@\315=\205L\306 \311=\205L\312p!\262
)
\203\210\204[\f\203|\316\317p!C\nC\"\320
\321!\322!S\323!	ABC$@\262
\202\245\324
\325\326 #\210\327 \202\245\f\203\243\316\317p!C\nC\"\320
\321!\322!\305$\262
\202\245\327 +\207" [edebug-current-offset edebug-offsets-stack edebug-offsets edebug-all-defs edebug-all-forms nil edebug-next-token-class lparen 1 symbol edebug-original-read get-edebug-spec &define name edebug-new-cursor edebug-read-storing-offsets edebug-make-form-wrapper edebug-before-offset edebug-after-offset symbol-name put edebug point-marker edebug-read-sexp] 11 "\n\n(fn)"])
(defalias 'edebug-interactive-p-name #[0 "\301\302\303\"!\207" [edebug-def-name intern format "edebug-%s-interactive-p"] 4 "\n\n(fn)"])
#@50 Wrap the FORMS of a definition body.

(fn FORMS)
(defalias 'edebug-wrap-def-body #[257 "\203\301\302 \303BC\304!E\207\304
!\207" [edebug-def-interactive let edebug-interactive-p-name ((interactive-p)) edebug-make-enter-wrapper] 5 (#$ . 29586)])
(defalias 'edebug-make-enter-wrapper #[257 "\206	\206\304\305!\306\307D\n\205\310\237B\311\312\313BBDF\207" [edebug-def-name edebug-old-def-name edebug-inside-func edebug-def-args edebug-gensym "edebug-anon" edebug-enter quote list function lambda nil] 8 "\n\n(fn FORMS)"])
(defalias 'edebug-inc-offset #[257 "
	Z\nBT\207" [edebug-offset-index edebug-form-begin-marker edebug-offset-list] 4 "\n\n(fn OFFSET)"])
(defalias 'edebug-make-before-and-after-form #[771 "\300\301DF\207" [edebug-after edebug-before] 7 "\n\n(fn BEFORE-INDEX FORM AFTER-INDEX)"])
(defalias 'edebug-make-after-form #[514 "\300\301F\207" [edebug-after 0] 6 "\n\n(fn FORM AFTER-INDEX)"])
#@215 Return the unwrapped SEXP or return it as is if it is not wrapped.
The SEXP might be the result of wrapping a body, which is a list of
expressions; a `progn' form will be returned enclosing these forms.

(fn SEXP)
(defalias 'edebug-unwrap #[257 "\211:\203\"\211@\300=\203\301
8\207\211@\302=\203!\303\3018A@AA!\207\207\207" [edebug-after 3 edebug-enter macroexp-progn] 4 (#$ . 30521)])
#@51 Return the SEXP recursively unwrapped.

(fn SEXP)
(defalias 'edebug-unwrap* #[257 "\300
!

=\204\211\262\300!\262
\202\211:\203 \301\302\"\202!\211\207" [edebug-unwrap mapcar edebug-unwrap*] 5 (#$ . 30918)])
(defalias 'edebug-defining-form #[1028 "\211\211@\262
\211A\262
A\240\210
\241\210\266\300S$\207" [edebug-make-form-wrapper] 9 "\n\n(fn CURSOR FORM-BEGIN FORM-END SPECLIST)"])
(defalias 'edebug-make-form-wrapper #[1027 "\306\"\211\203\211A@\202\307 \310\223\310\311\310@\310\211\211\211
\310\262\310\262\203;\312\"\202B\313\314	!C!\262
\f\206O
\206O\315\316!\204g\f\307 \310\223E\266\203\262\202\202\f\211\240\266A@\310\223\210\3178
\310\223\266\320!\210\321\322\f\"\210\323\237!\324\f!\210\325\f!\210\204\257\326p!\206\247\327 \211\330!B\210\331\f\332\310F#\210.\266\202)\207" [edebug-form-begin-marker edebug-inside-func edebug-def-interactive edebug-def-args edebug-def-name edebug-old-def-name edebug-get-form-data-entry make-marker nil 0 edebug-match edebug-make-enter-wrapper edebug-form edebug-gensym "edebug-anon" 2 edebug-make-top-form-data-entry message "Edebug: %s" vconcat edebug-clear-frequency-count edebug-clear-coverage get-buffer-window selected-window window-start put edebug edebug-offset-index edebug-offset-list edebug-top-window-data] 15 "\n\n(fn CURSOR FORM-BEGIN FORM-END &optional SPECLIST)"])
(defalias 'edebug-clear-frequency-count #[257 "\301
\302\303G\304\"#\207" [edebug-offset-list put edebug-freq-count make-vector 0] 7 "\n\n(fn NAME)"])
(defalias 'edebug-clear-coverage #[257 "\301
\302\303G\304\"#\207" [edebug-offset-list put edebug-coverage make-vector unknown] 7 "\n\n(fn NAME)"])
(defalias 'edebug-form #[257 "\300
\301\"
\211A@\262

:\203]
@\302=\203
\202}
@\2119\205$\303
!\304\"
:\203H
@\305=\203H\306
@\307	!\310!AB$\202X\311\312@!\313!\312\211A\262
!#\266\203\202}
9\203|
\314>\204n\315!\203r
\202}\316\312A!\"\202}
\317!\210\207" [edebug-top-element-required "Expected form" quote get-edebug-spec edebug-new-cursor &define edebug-defining-form edebug-after-offset symbol-name edebug-make-before-and-after-form edebug-inc-offset edebug-list-form (t nil) keywordp edebug-make-after-form edebug-move-cursor] 12 "\n\n(fn CURSOR)"])
(defalias 'edebug-forms #[257 "\300
\301\"\207" [edebug-match (&rest form)] 4 "\n\n(fn CURSOR)"])
(put 'edebug-forms 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-sexps #[257 "\300
\301\"\207" [edebug-match (&rest sexp)] 4 "\n\n(fn CURSOR)"])
(put 'edebug-sexps 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-list-form-args #[514 "\303!\211\203C\211:\203\304\211\305\"*\202h\211\306=\203(
\307
\310\"\262
\202h\211\311=\2038
\307
\312\"\262
\202h\2119\205h\211!\202h\313!\203a\n\203W
\307
\310\"\262
\202h
\307
\312\"\262
\202h
\307
\310\"\262
\207" [edebug-error-point edebug-best-error edebug-eval-macro-args get-edebug-spec nil edebug-match-sublist t edebug-match (&rest form) 0 (&rest sexp) edebug-macrop] 7 "\n\n(fn HEAD CURSOR)"])
(put 'edebug-list-form-args 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-list-form #[257 "\306
\307\"\310\311\211
\211\211@\262
\211A\262
A\240\210
\241\210\266\2119\203\263\211\204.\311\202\321\211\312=\203?\313\314!\210\315 \202\321\211
\314!\316!\211\203\207\211:\203\\\311\211\317\"*\202\255\211\310=\203l
\320
\321\"\262
\202\255\211\322=\203|
\320
\323\"\262
\202\255\2119\205\255\211!\202\255\324!\203\246\203\234
\320
\321\"\262
\202\255
\320
\323\"\262
\202\255
\320
\321\"\262
\266\203B\202\321\211:\203\316\211@\325=\203\306\320\326\"\202\321\327\330\327#\202\321\331\332!+\207" [edebug-&rest edebug-&optional edebug-gate edebug-def-interactive edebug-error-point edebug-best-error edebug-top-element-required "Expected elements" t nil interactive-p check-it edebug-move-cursor edebug-interactive-p-name get-edebug-spec edebug-match-sublist edebug-match (&rest form) 0 (&rest sexp) edebug-macrop \, (("," def-form) body) edebug-match-specs (lambda-expr body) edebug-syntax-error "Head of list form must be a symbol or lambda expression" edebug-eval-macro-args] 10 "\n\n(fn CURSOR)"])
(defvar edebug-after-dotted-spec nil)
(defvar edebug-matching-depth 0)
(defconst edebug-max-depth 150)
(defalias 'edebug-no-match #[385 "\206\304!	\206
\211\n\203\"\204\"\203b\210\305\306\"\207\307\310\"\207" [edebug-error-point edebug-best-error edebug-gate edebug-&optional edebug-before-offset apply edebug-syntax-error throw no-match] 5 "\n\n(fn CURSOR &rest ARGS)"])
(defalias 'edebug-match #[514 "\305\211\211\211\306\306#-\207" [edebug-gate edebug-error-point edebug-best-error edebug-&rest edebug-&optional nil edebug-match-specs] 7 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-one-spec #[514 "\2119\203\n\300\"\207\301
!\203\302\303\304\"\"\207\211;\203\"\305\"\207\211<\205+\306\"\207" [edebug-match-symbol vectorp edebug-match append nil edebug-match-string edebug-match-list] 7 "\n\n(fn CURSOR SPEC)"])
(defalias 'edebug-match-specs #[771 "	V\203\f\303\304!\202T
\204\305\202\262
:\204(\306\307C#)\202\262\211@\262
<\204h\n\204:\310\311\"\210\305\211@\262
\211A\262
\305\262C\240\210
\241\210\266\307#@)\266\203\202\262
@\305
9\205u\312!\313H\211\314=\203\207\315!A\"\202\250\211\316=\203\237AA\262\315!A@\"\202\250A\262\317\"#\244\266\203)\207" [edebug-matching-depth edebug-max-depth edebug-dotted-spec error "Too deep - perhaps infinite loop in spec?" nil t edebug-match-specs edebug-no-match "Dotted spec required." symbol-name 0 38 get-edebug-spec 58 edebug-match-one-spec] 11 "\n\n(fn CURSOR SPECS REMAINDER-HANDLER)"])
(byte-code "\300\211\203\211@\301
@\302A#\210
A\266\202\202
\207" [((&optional . edebug-match-&optional) (&rest . edebug-match-&rest) (&or . edebug-match-&or) (form . edebug-match-form) (sexp . edebug-match-sexp) (body . edebug-match-body) (&define . edebug-match-&define) (name . edebug-match-name) (:name . edebug-match-colon-name) (arg . edebug-match-arg) (def-body . edebug-match-def-body) (def-form . edebug-match-def-form) (lambda-expr . edebug-match-lambda-expr) (&not . edebug-match-&not) (&key . edebug-match-&key) (place . edebug-match-place) (gate . edebug-match-gate)) put edebug-form-spec] 6)
(defalias 'edebug-match-symbol #[514 "\300
!\211\203\211:\203\301\"\202\\\211!\202\\
\204#\302!\202\\\303!\203X\304\305#\211<\203A\211@\306=\203A\301\307\"\202S
!\204M\310\311#\210\312!\210\211C\262
\202\\\313\314\"\207" [get-edebug-spec edebug-match edebug-match-nil fboundp edebug-top-element-required "Expected" \, (("," def-form)) edebug-no-match "failed" edebug-move-cursor error "%s is not a form-spec or function"] 8 "\n\n(fn CURSOR SYMBOL)"])
(defalias 'edebug-match-sexp #[257 "\300
\301\"\302!\210C\207" [edebug-top-element-required "Expected sexp" edebug-move-cursor] 4 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-form #[257 "\300
!C\207" [edebug-form] 3 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-place 'edebug-match-form)
(defalias 'edebug-match-body #[257 "\211\300
\301\"\207" [edebug-match (&rest form)] 5 "\n\n(fn CURSOR)"])
(put 'edebug-match-body 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-match-&optional #[514 "\300\300#\207" [edebug-&optional-wrapper] 6 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-&optional-wrapper #[771 "\302C\302\211@\262
\211A\262
\302\262\302\262\303\304\305\306\307\310\311$\312\"\313\314%D\215\2048@\202H\240\210
\241\210\266\302*\207" [edebug-gate edebug-&optional nil no-match funcall make-byte-code 0 "\303\304\300\301\302#\240\210\305\207" vconcat vector [edebug-match-specs nil] 5 "\n\n(fn)"] 19 "\n\n(fn CURSOR SPECS REMAINDER-HANDLER)"])
(defalias 'edebug-&rest-wrapper #[771 "
\204\262\301#\207" [edebug-&rest edebug-&optional-wrapper] 7 "\n\n(fn CURSOR SPECS REMAINDER-HANDLER)"])
(defalias 'edebug-match-&rest #[514 "\211\303\211\304\304#+\207" [edebug-error-point edebug-best-error edebug-&rest nil edebug-&rest-wrapper] 6 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-&or #[514 "\211C\211@\211@\262
\211A\262
\300\301\302\303\304\305\306\f%\307\"\310\311%D\215\266\203\207" [matched funcall make-byte-code 0 "\301@\203.\305\306\307\310\311\312\313\300\301\"\314\"\315\316%D\215\210\301\211@A\240\210\300\303\304\240\210
\241\210\266\202\317\320\300\321\302$\207" vconcat vector [no-match funcall make-byte-code 0 "\305\306\307\211\211\310\300\301@@\"+\"\207" vconcat vector [edebug-error-point edebug-best-error edebug-gate throw matched nil edebug-match-one-spec] 5 "\n\n(fn)" apply edebug-no-match "Expected one of"] 9 "\n\n(fn)"] 18 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-&not #[514 "\300\301\302\303\304\305\306\"\307\"\310\311%D\215\204\312\313\"\210\314\207" [no-match funcall make-byte-code 0 "\303\212\304\300\301\"\210*\303\207" vconcat vector [edebug-gate nil edebug-match-&or] 3 "\n\n(fn)" edebug-no-match "Unexpected" nil] 11 "\n\n(fn CURSOR SPECS)"])
(put '&key 'edebug-form-spec 'edebug-match-&key)
(defalias 'edebug-match-&key #[514 "\300\301\302\303\"B\"\207" [edebug-match-&rest &or mapcar #[257 "\300\301\302@\"A@\"\207" [vector format ":%s"] 5 "\n\n(fn PAIR)"]] 8 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-gate #[257 "\301\302\207" [edebug-gate t nil] 2 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-list #[514 "\203\302\303\303#)\302\207\211@\304\305#
\306=\203CA@\2119\203:\211=\2040\307\305#\210\310!\210\311
\202>\312\313\"\262
\202\214\211<\203^\314\315\211A@\262
A\"\"C\310!\210\202\214
\316=\203\207\317
!\203\207\314\315\211A@\262
A\"A\"\310!\210\320\316\"C\262
\202\214\307\305#\207" [edebug-dotted-spec edebug-gate nil edebug-match-specs edebug-top-element-required "Expected" quote edebug-no-match edebug-move-cursor t error "Bad spec: %s" edebug-match-sublist edebug-new-cursor vector vectorp apply] 9 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-sublist #[514 "\302\303\303#\211@?\262
\204#	\203\304\305	#\210\202#\305\306#\210)\207" [edebug-&optional edebug-best-error nil edebug-match-specs apply edebug-no-match "Failed matching"] 7 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-string #[514 "\301\302#\303!
=\204\304\302#\202\305\306!\210\211C\207" [edebug-gate edebug-top-element-required "Expected" intern edebug-no-match t edebug-move-cursor] 7 "\n\n(fn CURSOR SPEC)"])
(defalias 'edebug-match-nil #[257 "\211\211@?\262
?\205\300
\301\"\207" [edebug-no-match "Unmatched argument(s)"] 4 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-function #[257 "\300\301!\207" [error "Use function-form instead of function in edebug spec"] 3 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-&define #[514 "\300\301!\211A\262
\211:\203\211A\262
\202\n\211\262
$\207" [edebug-make-form-wrapper edebug-before-offset] 7 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-lambda-expr #[257 "\301
\302\"
\211A@\262

:\205
@\2119\205\303
!\304\211:\203C\211@\305=\203C\306\307\"@\310!\311!AB$C\312!\210\202G\313\302\")\207" [edebug-inside-func edebug-top-element-required "Expected lambda expression" get-edebug-spec nil &define edebug-defining-form edebug-new-cursor edebug-after-offset symbol-name edebug-move-cursor edebug-no-match] 11 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-name #[257 "\301
\302\"\2119\204\303\304\"\210\203\305\306\307#!\202\211\310!\210\211C\207" [edebug-def-name edebug-top-element-required "Expected name" edebug-no-match "Symbol expected for name of definition" intern format "%s@%s" edebug-move-cursor] 7 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-colon-name #[514 "\203\301\302\303#!\202\211\304\207" [edebug-def-name intern format "%s@%s" nil] 7 "\n\n(fn CURSOR SPEC)"])
(defalias 'edebug-match-arg #[257 "\301
\302\"\2119\203\303
!\203\304\305#\210\306!\210\211B\211C\207" [edebug-def-args edebug-top-element-required "Expected arg" edebug-lambda-list-keywordp edebug-no-match "Bad argument:" edebug-move-cursor] 6 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-def-form #[257 "\301\302\303!C!)C\207" [edebug-inside-func nil edebug-make-enter-wrapper edebug-form] 4 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-def-body #[257 "\301\302
\303
\304\"\262
!)C\207" [edebug-inside-func t edebug-wrap-def-body edebug-match (&rest form)] 6 "\n\n(fn CURSOR)"])
#@86 Return non-nil if OBJECT is a symbol with an edebug-form-spec property.

(fn OBJECT)
(defalias 'edebug-spec-p #[257 "\2119\205\211\300N\207" [edebug-form-spec] 3 (#$ . 43467)])
(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#\210\300\313\302\314#\210\300\315\302\316#\210\300\317\302\320#\210\300\321\302\322#\210\300\322\302\323#\210\300\324\302\325#\210\300\326\302\327#\210\300\330\302\331#\210\300\332\302\333#\210\300\334\302\335#\210\300\336\302\334#\210\300\337\302\340#\210\300\341\302\337#\210\300\342\302\343#\210\300\344\302\345#\210\300\346\302\347#\210\300\350\302\351#\210\352\353\346\"\210\300\353\302\354#\210\300\355\302\356#\210\300\357\302\360#\210\300\361\302\362#\210\300\363\302\362#\207" [put def-edebug-spec edebug-form-spec (&define :name edebug-spec name &or "nil" edebug-spec-p "t" "0" (&rest edebug-spec)) edebug-spec-list ((edebug-spec . [&or nil edebug-spec])) edebug-spec (&or (vector &rest edebug-spec) ("vector" &rest edebug-spec) ("quote" symbolp) edebug-spec-list stringp [edebug-lambda-list-keywordp &rest edebug-spec] [keywordp gate edebug-spec] edebug-spec-p symbolp) quote sexp defconst defvar (symbolp &optional form stringp) defun (&define name lambda-list [&optional stringp] [&optional ("interactive" interactive)] def-body) defmacro (&define name lambda-list [&optional ("declare" &rest sexp)] def-body) arglist lambda-list (([&rest arg] [&optional ["&optional" arg &rest arg]] &optional ["&rest" arg])) interactive (&optional &or stringp def-form) function-form (&or ([&or "quote" "function"] &or symbolp lambda-expr) form) function (&or symbolp lambda-expr) macro (&define "lambda" lambda-list def-body) let ((&rest &or (symbolp &optional form) symbolp) body) let* setq (&rest symbolp form) setq-default cond (&rest (&rest form)) condition-case (symbolp form &rest ([&or symbolp (&rest symbolp)] body)) \` (backquote-form) backquote-form (&or ([&or "," ",@"] &or ("quote" backquote-form) form) (backquote-form [&rest [&not ","] backquote-form] . [&or nil backquote-form]) (vector &rest backquote-form) sexp) defalias edebug-\` (def-form) \, (&or ("quote" edebug-\`) def-form) \,@ (&define &or ("quote" edebug-\`) def-form) save-selected-window t save-current-buffer] 4)
(defvar edebug-active nil)
(byte-code "\301\236\204\f\301\302DB\301\207" [minor-mode-alist edebug-active " *Debugging*"] 2)
(defvar edebug-stack nil)
(defvar edebug-stack-depth -1)
(defvar edebug-offset-indices nil)
(defvar edebug-entered nil)
(defconst edebug-debugger 'edebug)
(defvar edebug-execution-mode 'step)
(defvar edebug-next-execution-mode nil)
#@701 Signal an error.  Args are SIGNAL-NAME, and associated DATA.
A signal name is a symbol with an `error-conditions' property
that is a list of condition names.
A handler for any of those names will get to handle this signal.
The symbol `error' should always be one of them.

DATA should be a list.  Its elements are printed as part of the error message.
If the signal is handled, DATA is made available to the handler.
See `condition-case'.

This is the Edebug replacement for the standard `signal'.  It should
only be active while Edebug is.  It checks `debug-on-error' to see
whether it should call the debugger.  When execution is resumed, the
error is signaled again.

(fn SIGNAL-NAME SIGNAL-DATA)
(defalias 'edebug-signal #[514 "<\203
>\203\302\303B\"\210\304\305\")\207" [debug-on-error signal-hook-function edebug error nil signal] 6 (#$ . 46117)])
(defalias 'edebug-enter #[771 "	\204K\306\307\n\\\310\\\f

\206\306\311\312DC\216\313 \206<!\206<\"\"\314 \315#.\202\230\316N\211#@$\317N\320N\321$!%&B&\322'B'\323N\203\207\324\"\323N\325=\203\207\326\323\314#\210(\203\224\327#\202\226\211 .)\207" [edebug-function edebug-entered max-lisp-eval-depth max-specpdl-size edebug-debugger debug-on-error t 100 200 funcall #[0 "\300\207" [nil] 1 "\n\n(fn)"] edebug-signal nil edebug-enter edebug edebug-freq-count edebug-coverage marker-buffer 0 edebug-on-entry step temp put edebug--enter-trace debug-on-quit edebug-on-error edebug-on-quit cl-lexical-debug edebug-outside-debug-on-quit edebug-outside-debug-on-error debugger signal-hook-function edebug-next-execution-mode edebug-initial-mode edebug-execution-mode edebug-data edebug-def-mark edebug-buffer edebug-stack edebug-offset-indices edebug-trace] 13 "\n\n(fn FUNCTION ARGS BODY)"])
#@426 Return a cons cell describing the status of VAR's current binding.
The purpose of this function is so you can properly undo
subsequent changes to the same binding, by passing the status
cons cell to `edebug-restore-status'.  The status cons cell
has the form (LOCUS . VALUE), where LOCUS can be a buffer
(for a buffer-local binding), a frame (for a frame-local binding),
or nil (if the default binding is current).

(fn VAR)
(defalias 'edebug-var-status #[257 "\300
!
JB\207" [variable-binding-locus] 3 (#$ . 47943)])
#@102 Reset VAR based on STATUS.
STATUS should be a list returned by `edebug-var-status'.

(fn VAR STATUS)
(defalias 'edebug-restore-status #[514 "\211@
A\300!\203\301!\205.r
q\210
L)\202.\302!\203+\303BC\"\202.
L\207" [bufferp buffer-live-p framep modify-frame-parameters] 8 (#$ . 48468)])
(defalias 'edebug--enter-trace #[771 "T\302\303\304\305#!\210\211 \211\306\304\307	#!\210*\207" [edebug-stack-depth edebug-result nil edebug-print-trace-before format "%s args: %s" edebug-print-trace-after "%s result: %s"] 9 "\n\n(fn FUNCTION ARGS BODY)"])
(put 'edebug-tracing 'edebug-form-spec '(form body))
#@120 Print MSG in *edebug-trace* before and after evaluating BODY.
The result of BODY is also printed.

(fn MSG &rest BODY)
(defalias 'edebug-tracing '(macro . #[385 "\300\301\302D\303\304\305\306BE\307\310\311	\312BBBDEF\207" [let ((edebug-stack-depth (1+ edebug-stack-depth)) edebug-result) edebug-print-trace-before prog1 setq edebug-result progn edebug-print-trace-after format "%s result: %s" (edebug-result)] 12 (#$ . 49092)]))
#@108 Function called to print trace info before expression evaluation.
MSG is printed after `::::{ '.

(fn MSG)
(defalias 'edebug-print-trace-before #[257 "\302\303\304	\305\"$\207" [edebug-trace-buffer edebug-stack-depth edebug-trace-display "%s{ %s" make-string 58] 7 (#$ . 49532)])
#@107 Function called to print trace info after expression evaluation.
MSG is printed after `::::} '.

(fn MSG)
(defalias 'edebug-print-trace-after #[257 "\302\303\304	\305\"$\207" [edebug-trace-buffer edebug-stack-depth edebug-trace-display "%s} %s" make-string 58] 7 (#$ . 49821)])
(defalias 'edebug-slow-before #[257 "\204!	
\240\210\n
\nHTI\210\304>\203\305 \203!\306
\307\310#\210\207" [edebug-active edebug-offset-indices edebug-freq-count edebug-execution-mode (Go-nonstop next) input-pending-p edebug-debugger before nil] 5 "\n\n(fn BEFORE-INDEX)"])
(defalias 'edebug-fast-before #[257 "\300\207" [nil] 2 "\n\n(fn BEFORE-INDEX)"])
(defalias 'edebug-slow-after #[771 "\203\207	\240\210\n\nHTI\210\203\305\"\210\f\306=\203&\307 \204&\207\310\311#\207" [edebug-active edebug-offset-indices edebug-freq-count edebug-test-coverage edebug-execution-mode edebug--update-coverage Go-nonstop input-pending-p edebug-debugger after] 7 "\n\n(fn BEFORE-INDEX AFTER-INDEX VALUE)"])
(defalias 'edebug-fast-after #[771 "\207" [] 4 "\n\n(fn BEFORE-INDEX AFTER-INDEX VALUE)"])
(defalias 'edebug-run-slow #[0 "\300\301\302\"\210\300\303\304\"\207" [defalias edebug-before edebug-slow-before edebug-after edebug-slow-after] 3 "\n\n(fn)"])
(defalias 'edebug-run-fast #[0 "\300\301\302\"\210\300\303\304\"\207" [defalias edebug-before edebug-fast-before edebug-after edebug-fast-after] 3 "\n\n(fn)"])
(edebug-run-slow)
(defalias 'edebug--update-coverage #[514 "H\211\301=\206!\211\302=\203I\202!

=?\205!\301I\207" [edebug-coverage ok-coverage unknown] 6 "\n\n(fn AFTER-INDEX VALUE)"])
(defvar edebug-break-result nil)
(defvar edebug-global-break-result nil)
(defalias 'edebug-debugger #[771 "\203\207	A@\n\236\211A@
\205!\306\307\310D\311\307\312\306EDC\217\313\206:\205:\f?\206:\314\f!\211\211\203Q\3158\203Q	\316\n\"	AAB\241\210\317>\203b\204b\320 \203h\321
#\210-\207" [inhibit-redisplay edebug-data edebug-breakpoints edebug-break-data edebug-break-condition edebug-global-break-condition #1=#:err funcall #[0 "\302!\211\207" [edebug-global-break-condition edebug-global-break-result eval] 2 "\n\n(fn)"] error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] nil eval 2 delq (go continue Continue-fast) input-pending-p edebug--display edebug-global-break edebug-break edebug-break-result edebug-execution-mode] 10 "\n\n(fn OFFSET-INDEX ARG-MODE VALUE)"])
(defvar edebug-eval-list nil)
(defvar edebug-previous-result nil)
(defalias 'edebug-mark-marker 'mark-marker)
(defalias 'edebug--display #[771 "\306!\204	\307 \210\310\311 \312\313	8H\\\312\314	8\315 p`\316 \n\312\211C\312\205*\317 \312C\312C\f
@\320\321!ABCDE\312\262F\312\262G\312\262H\312\262I\312\262		J\312\262\nK\312\262\f
L\312\262M\312\262\322\323\324\325\326\327!\330\"\314\331%DC\216\f
\312\211@\332\321\310\"\210\333N!\204\252\312O\334\335P\"\210)\336=\203\266\337!\210Q\203\301\340Q!FR\203\313\341 \240\210\342NK@\"\210K\315 \240\210\343!\210\344K@!\210Nq\210`\262
Lb\210\345=\203
g\346>\204
\312O\334\347P\"\210)K\350KA!\241\210\351 \203
\352S\310\262\353 \210\354 \210\334=\203F
\352S\354 \210\355 \210@\356=\203>
\357\360!\210\202}
\361!\210\202}
T\203y
U\203[
\357\362VW#\210\202}
X\203k
\357\363XY#\210\202}
S\364=\204}
\357\365!\210\202}
\357\366!\210\336=\203\230
T\203\225
S\364=\204\225
\367Z!\210\370 \210T\203\300
S\371=\203\254
\367Z!\210\202\332
S\364=\203\272
\367\324!\210\202\332
\310\262\202\332
S\372=\203\317
\367Z!\210\202\332
S\373=\203\332
\367\324!\210\322\323\324\374\326\327		$\375\"\376\331%DC\216\204S\377>\204\334=\203\201[!\210)rNq\210\fb.\207" [edebug-def-mark edebug-data unread-command-events edebug-eval-list overlay-arrow-position overlay-arrow-string marker-position debug t with-timeout-suspend nil 2 3 selected-window edebug-mark edebug-eval-result-list default-value cursor-in-non-selected-windows funcall make-byte-code 0 "	\203\306	!\210\307\300!\210\n\f\n\f
\310\311\"\207" vconcat vector [edebug-eval-buffer edebug-outside-unread-command-events unread-command-events edebug-outside-o-a-p overlay-arrow-position kill-buffer with-timeout-unsuspend set-default cursor-in-non-selected-windows edebug-outside-o-a-s overlay-arrow-string edebug-outside-c-i-e-a cursor-in-echo-area edebug-outside-d-c-i-n-s-w] "\n\n(fn)" set-default buffer-name error "Buffer defining %s not found" after edebug-compute-previous-result edebug-current-windows edebug-get-displayed-buffer-points edebug-pop-to-buffer edebug-eval-display select-window before (40 35 96) "Source has changed - reevaluate definition of %s" edebug-adjust-window input-pending-p step edebug-stop edebug-overlay-arrow beep quit message "Quit" edebug-report-error "Global Break: %s => %s" "Break: %s => %s" Continue-fast "Break" "" sit-for edebug-previous-result continue trace Trace-fast "\306 \f=\203\f\307 \202\310\f!\211\203

\240\210
\311!\241\210\210\302\310!\240\210\302@\2036\303\302@\2054\311\302@!\240\210\203p\312!\210\203J\313\301@!\210\302@\203V\314\302@\303@\"\210
@\315
!\203l\306 \f=\203l\314

A\316#\210\210\202z\315\300!\203z\317\300!\210\320!\203\205q\210\f=\204\220b\210\321\322 !\205\235\322 \323\223\207" [edebug-buffer edebug-window-data window-buffer selected-window get-buffer-window window-start edebug-set-windows edebug-set-buffer-points set-window-start edebug-window-live-p no-force select-window buffer-name marker-buffer edebug-mark-marker nil edebug-trace-buffer edebug-save-windows edebug-outside-windows edebug-save-displayed-buffer-points edebug-outside-buffer edebug-outside-point edebug-outside-mark] 5 (step next) cursor-in-echo-area edebug-outside-d-c-i-n-s-w edebug-outside-c-i-e-a edebug-outside-o-a-s edebug-outside-o-a-p edebug-eval-buffer edebug-outside-windows edebug-outside-unread-command-events edebug-outside-mark edebug-outside-point edebug-outside-buffer edebug-window-data edebug-point edebug-active edebug-buffer debug-on-error edebug-function edebug-save-windows edebug-save-displayed-buffer-points edebug-execution-mode edebug-break edebug-global-break edebug-global-break-condition edebug-global-break-result edebug-break-condition edebug-break-result edebug-sit-for-seconds edebug--recursive-edit] 30 "\n\n(fn VALUE OFFSET-INDEX ARG-MODE)"])
(defvar edebug-number-of-recursions 0)
(defvar edebug-recursion-depth 0)
(defalias 'edebug--recursive-edit #[257 "r	q\210\306 )\307 \310\211\211\211\311 \n\312\313!\312\314!\f
 !\"#$%&'()*+,-./0123456789:\315\316DC\216\310\211\211\211\211\211\317\211;\205k\n\310\211<=;\205w
\310\211\f>?@A%$#\"! B\320=\203\252
\321>\204\252\322\323!\210\317\310C\324 \210\315\325\326\327\330\331!\332\"\333\334%DC\216\335 .)\207" [buffer-read-only edebug-outside-buffer executing-kbd-macro standard-output standard-input defining-kbd-macro match-data recursion-depth nil current-local-map edebug-var-status pre-command-hook post-command-hook funcall #[0 "\n\f	\n\f
\306\307\"\210\306\310\"\207" [edebug-outside-last-command-event last-command-event edebug-outside-last-command last-command edebug-outside-this-command this-command edebug-restore-status post-command-hook pre-command-hook edebug-outside-current-prefix-arg current-prefix-arg edebug-outside-last-input-event last-input-event edebug-outside-last-event-frame last-event-frame edebug-outside-last-nonmenu-event last-nonmenu-event edebug-outside-track-mouse track-mouse edebug-outside-standard-output standard-output edebug-outside-standard-input standard-input edebug-outside-defining-kbd-macro defining-kbd-macro edebug-outside-executing-macro executing-kbd-macro edebug-outside-post-command-hook edebug-outside-pre-command-hook] 3 "\n\n(fn)"] t go (after error) message "Break" edebug-mode make-byte-code 0 "\306\n\203\n\307\n!\210\310!\210\311\f!\203.\fq\210
\312>\203 \313 \210\300\314!\210\315\316\317\320#\207\321\322!\207" vconcat vector [signal-hook-function edebug-backtrace-buffer edebug-outside-match-data edebug-buffer edebug-execution-mode edebug-signal kill-buffer set-match-data buffer-name (go Go-nonstop) edebug-overlay-arrow use-local-map remove-hook kill-buffer-hook edebug-kill-buffer t get-buffer-create " bogus edebug buffer" buffer-read-only edebug-outside-map] 4 "\n\n(fn)" recursive-edit last-command this-command current-prefix-arg last-input-event last-command-event last-event-frame last-nonmenu-event track-mouse edebug-outside-track-mouse edebug-outside-last-nonmenu-event edebug-outside-last-event-frame edebug-outside-last-command-event edebug-outside-last-input-event edebug-outside-current-prefix-arg edebug-outside-this-command edebug-outside-last-command edebug-outside-defining-kbd-macro edebug-outside-standard-input edebug-outside-standard-output edebug-outside-post-command-hook edebug-outside-pre-command-hook edebug-outside-executing-macro edebug-outside-map edebug-inside-windows edebug-backtrace-buffer edebug-interactive-p edebug-entered edebug-recursion-depth edebug-outside-match-data edebug-continue-kbd-macro edebug-outside-debug-on-error edebug-outside-debug-on-quit debug-on-quit debug-on-error overriding-terminal-local-map overriding-local-map edebug-execution-mode signal-hook-function] 23 "\n\n(fn ARG-MODE)"])
(defalias 'edebug-adjust-window #[257 "\300 \2041\211\203\301\302 \"\210\300 \2041\301\302 \212`\303 W\203#\304\202(\305 \306\245[y\210\307 \210`)\"\210\303 \207" [pos-visible-in-window-p set-window-start selected-window window-start -1 window-height 2 beginning-of-line] 5 "\n\n(fn OLD-START)"])
#@50 Association list of arrows for each edebug mode.
(defconst edebug-arrow-alist '((Continue-fast . "=") (Trace-fast . "-") (continue . ">") (trace . "->") (step . "=>") (next . "=>") (go . "<>") (Go-nonstop . "..")) (#$ . 59554))
(defalias 'edebug-overlay-arrow #[0 "\304 	\236A\305 \211
p\223\207" [edebug-execution-mode edebug-arrow-alist overlay-arrow-string overlay-arrow-position line-beginning-position make-marker] 5 "\n\n(fn)"])
#@180 Toggle the saving and restoring of all windows.
Also, each time you toggle it on, the inside and outside window
configurations become the same as the current configuration.

(fn)
(defalias 'edebug-toggle-save-all-windows #[0 "?\211\203
\303!\211\304\305\203\306\202\307\"\207" [edebug-save-windows edebug-outside-windows edebug-inside-windows edebug-current-windows message "Window saving is %s for all windows." "on" "off"] 4 (#$ . 59999) nil])
(defalias 'edebug-changing-windows '(macro . #[128 "\300\301\302\303\304\305\"BBBB\207" [let ((window (selected-window))) (setq edebug-inside-windows (edebug-current-windows t)) (edebug-set-windows edebug-outside-windows) append ((setq edebug-outside-windows (edebug-current-windows edebug-save-windows)) (edebug-set-windows edebug-inside-windows))] 8 "\n\n(fn &rest BODY)"]))
#@188 Toggle the saving and restoring of the selected window.
Also, each time you toggle it on, the inside and outside window
configurations become the same as the current configuration.

(fn)
(defalias 'edebug-toggle-save-selected-window #[0 "\303=\203\"\304 \305\303!\306\n!\210\307
\310 \"\305!\306	!\266\202Q\304 >\203:\307\304 \n\236\n\"\307\304 \"\202Q\304 \305\303!\306\n!\210\211B\305!\306	!\266\311\312\304 >\203^\313\202_\314\304 #\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows t selected-window edebug-current-windows edebug-set-windows delq edebug-window-list message "Window saving is %s for %s." "on" "off"] 4 (#$ . 60841) nil])
#@140 Toggle the saving and restoring of windows.
With prefix, toggle for just the selected window.
Otherwise, toggle for all windows.

(fn ARG)
(defalias 'edebug-toggle-save-windows #[257 "\211\203\300 \207\301 \207" [edebug-toggle-save-selected-window edebug-toggle-save-all-windows] 2 (#$ . 61533) "P"])
#@67 Show the debug windows and where we stopped in the program.

(fn)
(defalias 'edebug-where #[0 "\204\303\304!\210\305	!\210\nb\207" [edebug-active edebug-buffer edebug-point error "Edebug is not active" edebug-pop-to-buffer] 2 (#$ . 61842) nil])
#@81 Change to the outside window configuration.
Use `edebug-where' to return.

(fn)
(defalias 'edebug-view-outside #[0 "\204\305\306!\210\307	!\310!\210\fb\210\311\312\313\314!\"\207" [edebug-active edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-outside-point error "Edebug is not active" edebug-current-windows edebug-set-windows message "Window configuration outside of Edebug.  Return with %s" substitute-command-keys "\\<global-map>\\[edebug-where]"] 4 (#$ . 62096) nil])
#@167 Bounce the point in the outside current buffer.
If prefix argument ARG is supplied, sit for that many seconds
before returning.  The default is one second.

(fn ARG)
(defalias 'edebug-bounce-point #[257 "\204\305\306!\210\212\307 \310\311\312\313\314\315!\316\"\317\320%DC\216\321	!\210\nb\210\322\323p`\324\325 !\2035\326\325 !\2026\327$\210\330!\210\321\f@\")\262
)\207" [edebug-active edebug-outside-buffer edebug-outside-point edebug-buffer edebug-window-data error "Edebug is not active" current-window-configuration funcall make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 "\n\n(fn)" edebug-pop-to-buffer message "Current buffer: %s Point: %s Mark: %s" marker-buffer edebug-mark-marker marker-position "<not set>" sit-for] 9 (#$ . 62605) "p"])
(defalias 'edebug-find-stop-point #[0 "\303 \211\304N\211\203\305
!\203\306\307\"\210\211\262
\211@\310	8\212\311\312!\203*\313\314x\210`)\nZ\314\211G\262\315\262
\211W\203LHV\203L\211T\262
\2027\211W\203`HX\203`
B\202d\316\317\"+\207" [edebug-def-name edebug-data edebug-def-mark edebug-form-data-symbol edebug markerp error "%s is not instrumented for Edebug" 2 looking-at "[ 	]" " 	" nil 0 message "Point is not on an expression in %s."] 8 "\n\n(fn)"])
#@71 Move point to the next breakpoint, or first if none past point.

(fn)
(defalias 'edebug-next-breakpoint #[0 "\304 \211\205t\211@\211A\305N\211@	A@\306	8\307\204$\310\311!\202q\211\2038\211@@X\2038\211A\262
\202%\211\203A\211@\202C@\262\n@H\\b\210\310\312\3068\203Y\313\202Z\314A@\203l\315\316\317A@!\"\202m\314P\"\262
,\266\203\207" [edebug-def-name edebug-data edebug-def-mark edebug-breakpoints edebug-find-stop-point edebug 2 nil message "No breakpoints in this function." "%s" "Temporary " "" format "Condition: %s" edebug-safe-prin1-to-string] 13 (#$ . 63881) nil])
#@251 Modify the breakpoint for the form at point or after it.
Set it if FLAG is non-nil, clear it otherwise.  Then move to that point.
If CONDITION or TEMPORARY are non-nil, add those attributes to
the breakpoint.

(fn FLAG &optional CONDITION TEMPORARY)
(defalias 'edebug-modify-breakpoint #[769 "\304 \211\205i\211@\211A\305N\211@	A@\306	8\307\236\262
\310
\"\203K\311EB\312\"\203C\313\314#\210\202[\313\315\"\210\202[\211\203W\313\316\"\210\202[\313\317!\210	A\240\210\nH\\b,\266\203\207" [edebug-def-name edebug-data edebug-def-mark edebug-breakpoints edebug-find-stop-point edebug 2 nil delq edebug-sort-alist < message "Breakpoint set in %s with condition: %s" "Breakpoint set in %s" "Breakpoint unset in %s" "No breakpoint here"] 12 (#$ . 64487)])
#@101 Set the breakpoint of nearest sexp.
With prefix argument, make it a temporary breakpoint.

(fn ARG)
(defalias 'edebug-set-breakpoint #[257 "\300\301\302#\207" [edebug-modify-breakpoint t nil] 5 (#$ . 65278) "P"])
#@45 Clear the breakpoint of nearest sexp.

(fn)
(defalias 'edebug-unset-breakpoint #[0 "\300\301!\207" [edebug-modify-breakpoint nil] 2 (#$ . 65498) nil])
#@69 Set `edebug-global-break-condition' to EXPRESSION.

(fn EXPRESSION)
(defalias 'edebug-set-global-break-condition #[257 "\211\211\207" [edebug-global-break-condition] 3 (#$ . 65655) (byte-code "\205\303\304\"\305\306	\307\n@\232\203\310\202\302%\262
C\207" [edebug-global-break-condition read-expression-map read-expression-history format "%s" read-from-minibuffer "Global Condition: " t (read-expression-history . 1)] 8)])
(defalias 'edebug-set-mode #[771 "T\303 =\203\304\305\"\210\306 \207\304\305\"\207" [edebug-recursion-depth edebug-execution-mode edebug-next-execution-mode recursion-depth message "%s" exit-recursive-edit] 6 "\n\n(fn MODE SHORTMSG MSG)"])
(defalias 'edebug-step-through-mode 'edebug-step-mode)
#@35 Proceed to next stop point.

(fn)
(defalias 'edebug-step-mode #[0 "\300\301\302\303#\207" [edebug-set-mode step "" "Edebug will stop at next stop point."] 4 (#$ . 66400) nil])
#@43 Proceed to next `after' stop point.

(fn)
(defalias 'edebug-next-mode #[0 "\300\301\302\303#\207" [edebug-set-mode next "" "Edebug will stop after next eval."] 4 (#$ . 66582) nil])
#@101 Go, evaluating until break.
With prefix ARG, set temporary break at current point and go.

(fn ARG)
(defalias 'edebug-go-mode #[257 "\211\203\300\301!\210\302\303\304\305#\207" [edebug-set-breakpoint t edebug-set-mode go "Go..." "Edebug will go until break."] 5 (#$ . 66770) "P"])
#@101 Go, evaluating without debugging.
You can use `edebug-stop', or any editing command, to stop.

(fn)
(defalias 'edebug-Go-nonstop-mode #[0 "\300\301\302\303#\207" [edebug-set-mode Go-nonstop "Go-Nonstop..." "Edebug will not stop at breaks."] 4 (#$ . 67060) nil])
#@81 Begin trace mode.
Pauses for `edebug-sit-for-seconds' at each stop point.

(fn)
(defalias 'edebug-trace-mode #[0 "\300\301\302\303#\207" [edebug-set-mode trace "Tracing..." "Edebug will trace with pause."] 4 (#$ . 67328) nil])
#@100 Trace with no wait at each step.
Updates the display at each stop point, but does not pause.

(fn)
(defalias 'edebug-Trace-fast-mode #[0 "\300\301\302\303#\207" [edebug-set-mode Trace-fast "Trace fast..." "Edebug will trace without pause."] 4 (#$ . 67562) nil])
#@85 Begin continue mode.
Pauses for `edebug-sit-for-seconds' at each break point.

(fn)
(defalias 'edebug-continue-mode #[0 "\300\301\302\303#\207" [edebug-set-mode continue "Continue..." "Edebug will pause at breakpoints."] 4 (#$ . 67830) nil])
#@101 Trace with no wait at each step.
Updates the display at each break point, but does not pause.

(fn)
(defalias 'edebug-Continue-fast-mode #[0 "\300\301\302\303#\207" [edebug-set-mode Continue-fast "Continue fast..." "Edebug will stop and go at breakpoints."] 4 (#$ . 68079) nil])
#@74 Proceed to first stop-point at or after current position of point.

(fn)
(defalias 'edebug-goto-here #[0 "\300\301!\207" [edebug-go-mode t] 2 (#$ . 68364) nil])
#@91 Stop execution and do not continue.
Useful for exiting from trace or continue loop.

(fn)
(defalias 'edebug-stop #[0 "\300\301!\207" [message "Stop"] 2 (#$ . 68531) nil])
#@139 Proceed from the current point to the end of the ARGth sexp ahead.
If there are not ARG sexps ahead, then do `edebug-step-out'.

(fn ARG)
(defalias 'edebug-forward-sexp #[257 "\300\301\302\303\304\305\306!\307\"\310\311%D\312\301\313\300EDC\217\207" [#1=#:err funcall make-byte-code 0 "\302\303\300!\210\304\302!)\207" vconcat vector [parse-sexp-ignore-comments t forward-sexp edebug-go-mode] 2 "\n\n(fn)" error #[257 "\300 \207" [edebug-step-out] 2 "\n\n(fn IGNORED)"]] 9 (#$ . 68709) "p"])
#@210 Proceed from the current point to the end of the containing sexp.
If there is no containing sexp that is not the top level defun,
go to the end of the last sexp, or if that is the same point, then step.

(fn)
(defalias 'edebug-step-out #[0 "\300\301\302D\303\301\304\300EDC\217\207" [#1=#:err funcall #[0 "\301\302\303!\210\212\302\303!\210)\304\301!)\207" [parse-sexp-ignore-comments t up-list 1 edebug-go-mode] 2 "\n\n(fn)"] error #[257 "`\300\301!\210`
U\203\302 \202\303\304!\207" [down-list -1 edebug-step-mode edebug-go-mode t] 4 "\n\n(fn IGNORED)"]] 6 (#$ . 69211) nil])
(defalias 'edebug-instrument-function #[257 "\211\300N\301
!\203 \302
!\203 r\302
!q\210\211b\210\303 \210
)\202K\211:\203.\304\305\"\210
\202K\306\307\"\211A\204;\310\311!\210r\211@q\210\211Ab\210\303 \210)\262
\207" [edebug markerp marker-buffer edebug-eval-top-level-form message "%s is already instrumented." find-function-noselect t error "Could not find the definition in its file"] 5 "\n\n(fn FUNC)"])
#@269 Instrument the definition of the function or macro about to be called.
Do this when stopped before the form or it will be too late.
One side effect of using this command is that the next time the
function or macro is called, Edebug will be called there as well.

(fn)
(defalias 'edebug-instrument-callee #[0 "\300\301!\204\n\302\303!\207\212\304\305!\210\300\301!\203\306`!\211@\262
\202\"\307p!)\310
!\207" [looking-at "(" error "You must be before a list form" down-list 1 edebug-get-form-data-entry edebug-original-read edebug-instrument-function] 3 (#$ . 70219) nil])
#@214 Step into the definition of the function or macro about to be called.
This first does `edebug-instrument-callee' to ensure that it is
instrumented.  Then it does `edebug-on-entry' and switches to `go' mode.

(fn)
(defalias 'edebug-step-in #[0 "\300 \211\205\301
\302\"\210\303\304!\207" [edebug-instrument-callee edebug-on-entry temp edebug-go-mode nil] 4 (#$ . 70802) nil])
#@191 Cause Edebug to stop when FUNCTION is called.
With prefix argument, make this temporary so it is automatically
canceled the first time the function is entered.

(fn FUNCTION &optional FLAG)
(defalias 'edebug-on-entry #[513 "\300\301\203\302\202\f\303#\207" [put edebug-on-entry temp t] 6 (#$ . 71186) "aEdebug on entry to: \nP"])
(defalias 'cancel-edebug-on-entry #[257 "\300
\301\302#\207" [put edebug-on-entry nil] 5 "\n\n(fn FUNCTION)" "aEdebug on entry to: "])
(byte-code "\300\301!\204\301\302KM\210\300\207" [fboundp edebug-original-debug-on-entry debug-on-entry] 2)
#@128 Set mode to Go-nonstop, and exit to top-level.
This is useful for exiting even if `unwind-protect' code may be executed.

(fn)
(defalias 'edebug-top-level-nonstop #[0 "\301\302 \207" [edebug-execution-mode Go-nonstop top-level] 1 (#$ . 71773) nil])
#@112 Evaluate an expression list in the outside context.
Return the result of the last expression.

(fn &rest BODY)
(defalias 'edebug-outside-excursion '(macro . #[128 "\300\301\302\303\304\305\306\307\310\311\312\313\fBBBB\314BBF\257\207" [save-excursion (if edebug-save-windows (progn (setq edebug-inside-windows (edebug-current-windows edebug-save-windows)) (edebug-set-windows edebug-outside-windows))) (set-buffer edebug-buffer) (set-match-data edebug-outside-match-data) let ((last-command-event edebug-outside-last-command-event) (last-command edebug-outside-last-command) (this-command edebug-outside-this-command) (unread-command-events edebug-outside-unread-command-events) (current-prefix-arg edebug-outside-current-prefix-arg) (last-input-event edebug-outside-last-input-event) (last-event-frame edebug-outside-last-event-frame) (last-nonmenu-event edebug-outside-last-nonmenu-event) (track-mouse edebug-outside-track-mouse) (standard-output edebug-outside-standard-output) (standard-input edebug-outside-standard-input) (executing-kbd-macro edebug-outside-executing-macro) (defining-kbd-macro edebug-outside-defining-kbd-macro) (pre-command-hook (cdr edebug-outside-pre-command-hook)) (post-command-hook (cdr edebug-outside-post-command-hook)) (overlay-arrow-position edebug-outside-o-a-p) (overlay-arrow-string edebug-outside-o-a-s) (cursor-in-echo-area edebug-outside-c-i-e-a)) (setq-default cursor-in-non-selected-windows edebug-outside-d-c-i-n-s-w) unwind-protect with-current-buffer edebug-outside-buffer (goto-char edebug-outside-point) (if (marker-buffer (edebug-mark-marker)) (set-marker (edebug-mark-marker) edebug-outside-mark)) ((if edebug-save-windows (edebug-set-windows edebug-inside-windows)) (setq edebug-outside-last-command-event last-command-event edebug-outside-last-command last-command edebug-outside-this-command this-command edebug-outside-unread-command-events unread-command-events edebug-outside-current-prefix-arg current-prefix-arg edebug-outside-last-input-event last-input-event edebug-outside-last-event-frame last-event-frame edebug-outside-last-nonmenu-event last-nonmenu-event edebug-outside-track-mouse track-mouse edebug-outside-standard-output standard-output edebug-outside-standard-input standard-input edebug-outside-executing-macro executing-kbd-macro edebug-outside-defining-kbd-macro defining-kbd-macro edebug-outside-o-a-p overlay-arrow-position edebug-outside-o-a-s overlay-arrow-string edebug-outside-c-i-e-a cursor-in-echo-area edebug-outside-d-c-i-n-s-w (default-value 'cursor-in-non-selected-windows)) (setcdr edebug-outside-pre-command-hook pre-command-hook) (setcdr edebug-outside-post-command-hook post-command-hook) (setq-default cursor-in-non-selected-windows t))] 14 (#$ . 72030)]))
(put 'edebug-outside-excursion 'edebug-form-spec t)
(defalias 'edebug-eval #[257 "\302\303\300!\203\203\304\305!\203\305\"\202
	\"\207" [cl-debug-env lexical-binding eval boundp fboundp cl-macroexpand-all] 5 "\n\n(fn EXPR)"])
(defalias 'edebug-safe-eval #[257 "\300\301\302\303\304\305\306!\307\"\310\311%D\312\301\313\300EDC\217\207" [#1=#:err funcall make-byte-code 0 "\301\300!\207" vconcat vector [edebug-eval] 2 "\n\n(fn)" error #[257 "\300\301@\302NA@#\207" [edebug-format "%s: %s" error-message] 5 "\n\n(fn EDEBUG-ERR)"]] 9 "\n\n(fn EXPR)"])
(defalias 'edebug-report-error #[257 "\300\301@\302N\206\303\304@\"\305\306A\307##\207" [message "%s: %s" error-message format "peculiar error (%s)" mapconcat #[257 "\300
!\207" [prin1-to-string] 3 "\n\n(fn EDEBUG-ARG)"] ", "] 8 "\n\n(fn VALUE)"])
(defalias 'edebug-safe-prin1-to-string #[257 "\306\206	\n\206\f\206
\307\310\311\312\313\314\315\316!\317\"\320\321%D\322\311\323\310EDC\217-\207" [edebug-print-length print-length edebug-print-level print-level edebug-print-circle print-circle t nil #1=#:err funcall make-byte-code 0 "\301\300!\207" vconcat vector [edebug-prin1-to-string] 2 "\n\n(fn)" error #[257 "\300\207" ["#Apparently circular structure#"] 2 "#Apparently circular structure#\n\n(fn IGNORED)"] print-readably print-escape-newlines] 9 "\n\n(fn VALUE)"])
(defalias 'edebug-compute-previous-result #[257 "\203	\302
!\262
\303\304!\305!Q\211\207" [edebug-unwrap-results edebug-previous-result edebug-unwrap* "Result: " edebug-safe-prin1-to-string eval-expression-print-format] 5 "\n\n(fn PREVIOUS-VALUE)"])
#@34 Print the previous result.

(fn)
(defalias 'edebug-previous-result #[0 "\301\302\"\207" [edebug-previous-result message "%s"] 3 (#$ . 76399) nil])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\207" [defalias edebug-prin1 prin1 edebug-print print edebug-prin1-to-string prin1-to-string edebug-format format edebug-message message] 3)
#@134 Evaluate an expression in the outside environment.
If interactive, prompt for the expression.
Print result in minibuffer.

(fn EXPR)
(defalias 'edebug-eval-expression #[257 "\306\212\203\307!\310\n!\210q\210\311\f!\210
 A!A\"#$%&'()*+,-./0123456\312\3137\"\210\314\315DC\216r8q\2109b\210\316\317 !\203\200\317 :\320\223\210\321!;B;\322;@!\323;@!P.!\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-last-command-event princ edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows funcall #[0 "\203\306	!\210\n\f\f
 !\"#$%&\307\310!'()\241\210*+\241\210\311\310\312\"\207" [edebug-save-windows edebug-inside-windows last-command-event edebug-outside-last-command-event last-command edebug-outside-last-command edebug-set-windows default-value cursor-in-non-selected-windows set-default t this-command edebug-outside-this-command unread-command-events edebug-outside-unread-command-events current-prefix-arg edebug-outside-current-prefix-arg last-input-event edebug-outside-last-input-event last-event-frame edebug-outside-last-event-frame last-nonmenu-event edebug-outside-last-nonmenu-event track-mouse edebug-outside-track-mouse standard-output edebug-outside-standard-output standard-input edebug-outside-standard-input executing-kbd-macro edebug-outside-executing-macro defining-kbd-macro edebug-outside-defining-kbd-macro overlay-arrow-position edebug-outside-o-a-p overlay-arrow-string edebug-outside-o-a-s cursor-in-echo-area edebug-outside-c-i-e-a edebug-outside-d-c-i-n-s-w edebug-outside-pre-command-hook pre-command-hook edebug-outside-post-command-hook post-command-hook] 3 "\n\n(fn)"] marker-buffer edebug-mark-marker nil edebug-eval edebug-safe-prin1-to-string eval-expression-print-format edebug-outside-last-command edebug-outside-this-command edebug-outside-unread-command-events edebug-outside-current-prefix-arg edebug-outside-last-input-event edebug-outside-last-event-frame edebug-outside-last-nonmenu-event edebug-outside-track-mouse edebug-outside-standard-output edebug-outside-standard-input edebug-outside-executing-macro edebug-outside-defining-kbd-macro edebug-outside-pre-command-hook edebug-outside-post-command-hook edebug-outside-o-a-p edebug-outside-o-a-s edebug-outside-c-i-e-a cursor-in-echo-area overlay-arrow-string overlay-arrow-position post-command-hook pre-command-hook defining-kbd-macro executing-kbd-macro standard-input standard-output track-mouse last-nonmenu-event last-event-frame last-input-event current-prefix-arg unread-command-events this-command last-command last-command-event edebug-outside-d-c-i-n-s-w edebug-outside-buffer edebug-outside-point edebug-outside-mark values] 20 (#$ . 76793) (byte-code "\301\302\303\304\305%C\207" [read-expression-map read-from-minibuffer "Eval: " nil t read-expression-history] 6)])
#@89 Evaluate sexp before point in the outside environment.
Print value in minibuffer.

(fn)
(defalias 'edebug-eval-last-sexp #[0 "\300\301 !\207" [edebug-eval-expression edebug-last-sexp] 2 (#$ . 79813) nil])
#@115 Evaluate sexp before point in outside environment; insert value.
This prints the value into current buffer.

(fn)
(defalias 'edebug-eval-print-last-sexp #[0 "\306 \212\203\307!\310\n!\210q\210\311\f!\210
 !A\"A#$%&'()*+,-./01234567\312\3138\"\210\314\315DC\216r9q\210:b\210\316\317 !\203\201\317 ;\320\223\210\321\322!!.p.\323\324!\210\323
!\210\323\324!)\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-last-command-event edebug-last-sexp edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows funcall #[0 "\203\306	!\210\n\f\f
 !\"#$%&\307\310!'()\241\210*+\241\210\311\310\312\"\207" [edebug-save-windows edebug-inside-windows last-command-event edebug-outside-last-command-event last-command edebug-outside-last-command edebug-set-windows default-value cursor-in-non-selected-windows set-default t this-command edebug-outside-this-command unread-command-events edebug-outside-unread-command-events current-prefix-arg edebug-outside-current-prefix-arg last-input-event edebug-outside-last-input-event last-event-frame edebug-outside-last-event-frame last-nonmenu-event edebug-outside-last-nonmenu-event track-mouse edebug-outside-track-mouse standard-output edebug-outside-standard-output standard-input edebug-outside-standard-input executing-kbd-macro edebug-outside-executing-macro defining-kbd-macro edebug-outside-defining-kbd-macro overlay-arrow-position edebug-outside-o-a-p overlay-arrow-string edebug-outside-o-a-s cursor-in-echo-area edebug-outside-c-i-e-a edebug-outside-d-c-i-n-s-w edebug-outside-pre-command-hook pre-command-hook edebug-outside-post-command-hook post-command-hook] 3 "\n\n(fn)"] marker-buffer edebug-mark-marker nil edebug-safe-prin1-to-string edebug-safe-eval princ "\n" edebug-outside-last-command edebug-outside-this-command edebug-outside-unread-command-events edebug-outside-current-prefix-arg edebug-outside-last-input-event edebug-outside-last-event-frame edebug-outside-last-nonmenu-event edebug-outside-track-mouse edebug-outside-standard-output edebug-outside-standard-input edebug-outside-executing-macro edebug-outside-defining-kbd-macro edebug-outside-pre-command-hook edebug-outside-post-command-hook edebug-outside-o-a-p edebug-outside-o-a-s edebug-outside-c-i-e-a cursor-in-echo-area overlay-arrow-string overlay-arrow-position post-command-hook pre-command-hook defining-kbd-macro executing-kbd-macro standard-input standard-output track-mouse last-nonmenu-event last-event-frame last-input-event current-prefix-arg unread-command-events this-command last-command last-command-event edebug-outside-d-c-i-n-s-w edebug-outside-buffer edebug-outside-point edebug-outside-mark] 19 (#$ . 80025) nil])
#@162 If non-nil, inhibit Edebug bindings on the C-x C-a key.
By default, loading the `edebug' library causes these bindings to
be installed in `emacs-lisp-mode-map'.
(defvar edebug-inhibit-emacs-lisp-mode-bindings nil (#$ . 82918))
(byte-code "\302\303\300\304#\210\305\211\203(\211@\303
N\203!\300
N\204!\306\300\303N#\210
A\266\202\202\210\307\303\300\310#\210\204K\311	\312\313#\210\311	\314\315#\210\311	\316\317#\210\311	\320\321#\210\304\207" [edebug-inhibit-emacs-lisp-mode-bindings emacs-lisp-mode-map defvaralias gud-inhibit-global-bindings nil (saved-value saved-variable-comment) put make-obsolete-variable "24.3" define-key "
" edebug-step-mode "
" edebug-next-mode "
" edebug-go-mode "
\f" edebug-where] 7)
(defvar edebug-mode-map (byte-code "\301!\302
\303\304#\210\302
\305\306#\210\302
\307\310#\210\302
\311\312#\210\302
\313\314#\210\302
\315\316#\210\302
\317\320#\210\302
\321\322#\210\302
\323\324#\210\302
\325\326#\210\302
\327\330#\210\302
\331\332#\210\302
\333\334#\210\302
\335\336#\210\302
\337\340#\210\302
\341\342#\210\302
\343\344#\210\302
\345\346#\210\302
\347\350#\210\302
\351\352#\210\302
\353\354#\210\302
\355\356#\210\302
\357\360#\210\302
\361\362#\210\302
\363\364#\210\302
\365\366#\210\302
\367\370#\210\302
\371\372#\210\302
\373\374#\210\302
\375\372#\210\302
\376\377#\210\302
\201@\201A#\210\302
\201B\201C#\210\302
\201D\201E#\210\302
\201F\201G#\210\302
\201H\304#\210\302
\201I\306#\210\302
\201J\310#\210\302
\201K\346#\210\302
\201L\350#\210\302
\201M\201N#\210\302
\201O\370#\210\211\207" [emacs-lisp-mode-map copy-keymap define-key " " edebug-step-mode "n" edebug-next-mode "g" edebug-go-mode "G" edebug-Go-nonstop-mode "t" edebug-trace-mode "T" edebug-Trace-fast-mode "c" edebug-continue-mode "C" edebug-Continue-fast-mode "f" edebug-forward-sexp "h" edebug-goto-here "I" edebug-instrument-callee "i" edebug-step-in "o" edebug-step-out "q" top-level "Q" edebug-top-level-nonstop "a" abort-recursive-edit "S" edebug-stop "b" edebug-set-breakpoint "u" edebug-unset-breakpoint "B" edebug-next-breakpoint "x" edebug-set-conditional-breakpoint "X" edebug-set-global-break-condition "r" edebug-previous-result "e" edebug-eval-expression "" edebug-eval-last-sexp "E" edebug-visit-eval-list "w" edebug-where "v" edebug-view-outside "p" edebug-bounce-point "P" "W" edebug-toggle-save-windows "?" edebug-help "d" edebug-backtrace "-" negative-argument "=" edebug-temp-display-freq-count "" "" "" " " "" "" #[0 "\300\301!\207" [edebug-set-breakpoint t] 2 "\n\n(fn)" nil] "\f"] 5))
#@67 Prefix key for global edebug commands, available from any buffer.
(defvar global-edebug-prefix "X" (#$ . 85492))
#@59 Global map of edebug commands, available from any buffer.
(defvar global-edebug-map (byte-code "\300 \301
\302\303#\210\301
\304\305#\210\301
\306\307#\210\301
\310\311#\210\301
\312\313#\210\301
\314\315#\210\301
\316\317#\210\301
\320\321#\210\301
\322\323#\210\301
\324\325#\210\301
\326\327#\210\301
\330\331#\210\301
\332\333#\210\301
\334\335#\210\301
\336\337#\210\301
\340\341#\210\301
\342\343#\210\211\207" [make-sparse-keymap define-key " " edebug-step-mode "g" edebug-go-mode "G" edebug-Go-nonstop-mode "t" edebug-trace-mode "T" edebug-Trace-fast-mode "c" edebug-continue-mode "C" edebug-Continue-fast-mode "b" edebug-set-breakpoint "u" edebug-unset-breakpoint "x" edebug-set-conditional-breakpoint "X" edebug-set-global-break-condition "w" edebug-where "W" edebug-toggle-save-windows "q" top-level "Q" edebug-top-level-nonstop "a" abort-recursive-edit "=" edebug-display-freq-count] 5) (#$ . 85612))
(byte-code "\302!\210\303	\"\207" [global-edebug-prefix global-edebug-map global-unset-key global-set-key] 3)
#@31 Describe `edebug-mode'.

(fn)
(defalias 'edebug-help #[0 "\300\301!\207" [describe-function edebug-mode] 2 (#$ . 86643) nil])
#@925 Mode for Emacs Lisp buffers while in Edebug.

In addition to all Emacs Lisp commands (except those that modify the
buffer) there are local and global key bindings to several Edebug
specific commands.  E.g. `edebug-step-mode' is bound to \[edebug-step-mode]
in the Edebug buffer and \<global-map>\[edebug-step-mode] in any buffer.

Also see bindings for the eval list buffer *edebug* in `edebug-eval-mode'.

The edebug buffer commands:
\{edebug-mode-map}

Global commands prefixed by `global-edebug-prefix':
\{global-edebug-map}

Options:
`edebug-setup-hook'
`edebug-all-defs'
`edebug-all-forms'
`edebug-save-windows'
`edebug-save-displayed-buffer-points'
`edebug-initial-mode'
`edebug-trace'
`edebug-test-coverage'
`edebug-continue-kbd-macro'
`edebug-print-length'
`edebug-print-level'
`edebug-print-circle'
`edebug-on-error'
`edebug-on-quit'
`edebug-on-signal'
`edebug-unwrap-results'
`edebug-global-break-condition'

(fn)
(defalias 'edebug-mode #[0 "\301\302\303\304\305$\210\306!\207" [edebug-mode-map add-hook kill-buffer-hook edebug-kill-buffer nil t use-local-map] 5 (#$ . 86776)])
#@85 Used on `kill-buffer-hook' when Edebug is operating in a buffer of Lisp code.

(fn)
(defalias 'edebug-kill-buffer #[0 "\301\302p!\210)\303 \207" [kill-buffer-hook nil kill-buffer top-level] 2 (#$ . 87871)])
#@59 Return a list of evaluations of `edebug-eval-list'.

(fn)
(defalias 'edebug-eval-result-list #[0 "\303\304\305\306\n\"*\207" [edebug-trace edebug-execution-mode edebug-eval-list Go-nonstop nil mapcar edebug-safe-eval] 3 (#$ . 88085)])
(defalias 'edebug-eval-display-list #[257 "\303\304\305\306 \307Z\310\"\"
\311\262q\210\312 \210\n\211\203;\211@\313
!\210\314 \210\313\211A\262@!\210\314 \210\315!\210
A\266\202\202\210\316!)\207" [edebug-eval-buffer standard-output edebug-eval-list format ";%s\n" make-string window-width 2 45 nil erase-buffer prin1 terpri princ edebug-pop-to-buffer] 8 "\n\n(fn EVAL-RESULT-LIST)"])
(defalias 'edebug-create-eval-buffer #[0 "\205\301!?\205\302\303!\211q\210\304 \207" [edebug-eval-buffer buffer-name get-buffer-create "*edebug*" edebug-eval-mode] 2 "\n\n(fn)"])
#@137 Display expressions and evaluations in EVAL-RESULT-LIST.
It modifies the context by popping up the eval display.

(fn EVAL-RESULT-LIST)
(defalias 'edebug-eval-display #[257 "\211\205\n\300 \210\301
!\207" [edebug-create-eval-buffer edebug-eval-display-list] 3 (#$ . 88912)])
#@108 Redisplay eval list in outside environment.
May only be called from within `edebug--recursive-edit'.

(fn)
(defalias 'edebug-eval-redisplay #[0 "\306 \210\212\203\307!\310\n!\210q\210\311\f!\210
A A!\"#$%&'()*+,-./012345\312\3136\"\210\314\315DC\216r7q\2108b\210\316\317 !\203\202\317 9\320\223\210\321\322 !.\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-last-command-event edebug-create-eval-buffer edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows funcall #[0 "\203\306	!\210\n\f\f
 !\"#$%&\307\310!'()\241\210*+\241\210\311\310\312\"\207" [edebug-save-windows edebug-inside-windows last-command-event edebug-outside-last-command-event last-command edebug-outside-last-command edebug-set-windows default-value cursor-in-non-selected-windows set-default t this-command edebug-outside-this-command unread-command-events edebug-outside-unread-command-events current-prefix-arg edebug-outside-current-prefix-arg last-input-event edebug-outside-last-input-event last-event-frame edebug-outside-last-event-frame last-nonmenu-event edebug-outside-last-nonmenu-event track-mouse edebug-outside-track-mouse standard-output edebug-outside-standard-output standard-input edebug-outside-standard-input executing-kbd-macro edebug-outside-executing-macro defining-kbd-macro edebug-outside-defining-kbd-macro overlay-arrow-position edebug-outside-o-a-p overlay-arrow-string edebug-outside-o-a-s cursor-in-echo-area edebug-outside-c-i-e-a edebug-outside-d-c-i-n-s-w edebug-outside-pre-command-hook pre-command-hook edebug-outside-post-command-hook post-command-hook] 3 "\n\n(fn)"] marker-buffer edebug-mark-marker nil edebug-eval-display-list edebug-eval-result-list edebug-outside-last-command edebug-outside-this-command edebug-outside-unread-command-events edebug-outside-current-prefix-arg edebug-outside-last-input-event edebug-outside-last-event-frame edebug-outside-last-nonmenu-event edebug-outside-track-mouse edebug-outside-standard-output edebug-outside-standard-input edebug-outside-executing-macro edebug-outside-defining-kbd-macro edebug-outside-pre-command-hook edebug-outside-post-command-hook edebug-outside-o-a-p edebug-outside-o-a-s edebug-outside-c-i-e-a cursor-in-echo-area overlay-arrow-string overlay-arrow-position post-command-hook pre-command-hook defining-kbd-macro executing-kbd-macro standard-input standard-output track-mouse last-nonmenu-event last-event-frame last-input-event current-prefix-arg unread-command-events this-command last-command last-command-event edebug-outside-d-c-i-n-s-w edebug-outside-buffer edebug-outside-point edebug-outside-mark] 18 (#$ . 89195)])
#@56 Switch to the evaluation list buffer "*edebug*".

(fn)
(defalias 'edebug-visit-eval-list #[0 "\301 \210\302!\207" [edebug-eval-buffer edebug-eval-redisplay edebug-pop-to-buffer] 2 (#$ . 92039) nil])
#@74 Replace the evaluation list with the sexps now in the eval buffer.

(fn)
(defalias 'edebug-update-eval-list #[0 "`\301eb\210\302 \210m\204\303\304!\210\305 
B\262
\306\307\301\310#\203<\304y\210\311\301w\210g\312U\204m\204\303\304!\210\305 
B\262
\202\211\237\313 \210
b\207" [edebug-eval-list nil edebug-skip-whitespace forward-sexp 1 edebug-last-sexp re-search-forward "^;" t " 	\n
" 59 edebug-eval-redisplay] 6 (#$ . 92245) nil])
#@50 Delete the item under point and redisplay.

(fn)
(defalias 'edebug-delete-eval-item #[0 "\300\301\302\303#\203\304y\210`\305\301\302\303#\210\306 \210`|\210\307 \207" [re-search-backward "^;" nil nofail 1 re-search-forward beginning-of-line edebug-update-eval-list] 5 (#$ . 92694) nil])
#@66 Keymap for Edebug Eval mode.  Superset of Lisp Interaction mode.
(defvar edebug-eval-mode-map (byte-code "\301 \302
\"\210\303
\304\305#\210\303
\306\307#\210\303
\310\311#\210\303
\312\313#\210\303
\314\315#\210\211\207" [lisp-interaction-mode-map make-sparse-keymap set-keymap-parent define-key "" edebug-where "" edebug-delete-eval-item "" edebug-update-eval-list "" edebug-eval-last-sexp "\n" edebug-eval-print-last-sexp] 5) (#$ . 92989))
(byte-code "\300\301\302\303#\210\304\305N\204\300\304\305\306\307!#\210\310\311!\204 \300\311\312\301#\210\300\207" [put edebug-eval-mode mode-class special edebug-eval-mode-hook variable-documentation purecopy "Hook run when entering Edebug Eval mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp edebug-eval-mode-map definition-name] 5)
(defvar edebug-eval-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [edebug-eval-mode-map variable-documentation put purecopy "Keymap for `edebug-eval-mode'." boundp edebug-eval-mode-syntax-table definition-name edebug-eval-mode] 5)
(defvar edebug-eval-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [edebug-eval-mode-syntax-table variable-documentation put purecopy "Syntax table for `edebug-eval-mode'." edebug-eval-mode-abbrev-table definition-name edebug-eval-mode] 5)
(defvar edebug-eval-mode-abbrev-table (progn (define-abbrev-table 'edebug-eval-mode-abbrev-table nil) edebug-eval-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [edebug-eval-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `edebug-eval-mode'." edebug-eval-mode derived-mode-parent lisp-interaction-mode] 5)
#@613 Mode for evaluation list buffer while in Edebug.

In addition to all Interactive Emacs Lisp commands there are local and
global key bindings to several Edebug specific commands.  E.g.
`edebug-step-mode' is bound to \[edebug-step-mode] in the Edebug
buffer and \<global-map>\[edebug-step-mode] in any buffer.

Eval list buffer commands:
\{edebug-eval-mode-map}

Global commands prefixed by `global-edebug-prefix':
\{global-edebug-map}

In addition to any hooks its parent mode `lisp-interaction-mode' might have run,
this mode runs the hook `edebug-eval-mode-hook', as the final step
during initialization.

(fn)
(defalias 'edebug-eval-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
)\331\332!\207" [delay-mode-hooks major-mode mode-name edebug-eval-mode-map edebug-eval-mode-syntax-table edebug-eval-mode-abbrev-table make-local-variable t lisp-interaction-mode edebug-eval-mode "Edebug Eval" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks edebug-eval-mode-hook local-abbrev-table] 5 (#$ . 94883) nil])
#@161 Replacement for `debug'.
If we are running an edebugged function, show where we last were.
Otherwise call `debug' normally.

(fn &optional ARG-MODE &rest ARGS)
(defalias 'edebug #[384 "\203.\306 	=\203.\n@
@\307\211\211\211?\f
\310
#\210\311=?\205,\211-\207\312\313#\207" [edebug-entered edebug-recursion-depth edebug-offset-indices edebug-break edebug-global-break edebug-break-condition recursion-depth nil edebug--display error apply debug edebug-break-data edebug-breakpoints] 9 (#$ . 96266)])
#@64 Display a non-working backtrace.  Better than nothing...

(fn)
(defalias 'edebug-backtrace #[0 "\203\n\306!\204\307\310!	r\311\306!!q\210p\312 \210
\313\211\314\211\314\315 \210\316\317!\210+\211\211\314\320\313
\313\262\313\262\321 \210q\210\314eb\210`\262
\322\323\313\314#\205\201\324 \210\325\326!\203q`\262
\327y\210\211`|\210\202S\325\330!\203S\327y\210\211`|\210\202S*\266\203\331!\210)\207" [edebug-backtrace-buffer default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks buffer-name generate-new-buffer "*Backtrace*" get-buffer-create kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook 50 backtrace re-search-forward "^  (?edebug" beginning-of-line looking-at "^  (edebug-after" 1 "^  edebug" internal-temp-output-buffer-show inhibit-read-only standard-output print-length print-escape-newlines truncate-lines] 10 (#$ . 96787) nil])
#@226 In buffer BUF-NAME, display FMT and ARGS at the end and make it visible.
The buffer is created if it does not exist.
You must include newlines in FMT to break lines, but one newline is appended.

(fn BUF-NAME FMT &rest ARGS)
(defalias 'edebug-trace-display #[642 "p\301 \302!\303\304!\210\305\301 \262
db\210\306\307#\310\261\210\311\312\313 Z!\210\314
`\"\210db\210\315!\210\316!\210q\266\207" [truncate-lines selected-window get-buffer-create nil edebug-pop-to-buffer t apply edebug-format "\n" vertical-motion 1 window-height set-window-start bury-buffer select-window] 11 (#$ . 97735)])
#@94 Convenience call to `edebug-trace-display' using `edebug-trace-buffer'.

(fn FMT &rest ARGS)
(defalias 'edebug-trace #[385 "\301\302$\207" [edebug-trace-buffer apply edebug-trace-display] 7 (#$ . 98345)])
#@734 Display the frequency count data for each line of the current definition.
The frequency counts are inserted as comment lines after each line,
and you can undo all insertions with one `undo' command.

The counts are inserted starting under the `(' before an expression
or the `)' after an expression, or on the last char of a symbol.
The counts are only displayed when they differ from previous counts on
the same line.

If coverage is being tested, whenever all known results of an expression
are `eq', the char `=' will be appended after the count
for that expression.  Note that this is always the case for an
expression only evaluated once.

To clear the frequency count and coverage data for a definition,
reinstrument it.

(fn)
(defalias 'edebug-display-freq-count #[0 "\300 \211\301N
\302N\303N\211@\3048\211GS\305\211\211\211\211\212\306X\205\304H\\b\210\307 \210`Z\262\262\306S\211\262X\203KHX\2046\310y\210`\262\262\311\262
\312c\210T\211\262X\203\273\nH\nH\212H\n\\b\210ig\313U\203\204\306\202\205\310Z)\314\306`ZZ]\315\"\306W\203\242\316>\204\242\317\202\243\320U\203\256\320\202\261\321!\322\261\210\266\204\202Z\323c\210\262\202)\207" [edebug-form-data-symbol edebug-freq-count edebug-coverage edebug 2 nil 0 beginning-of-line 1 -1 ";#" 40 make-string 32 (unknown ok-coverage) "=" "" int-to-string " " "\n"] 20 (#$ . 98560) nil])
#@117 Temporarily display the frequency count data for the current definition.
It is removed when you hit any char.

(fn)
(defalias 'edebug-temp-display-freq-count #[0 "\302\303 \210\304 \210\305	\306 C\"\307 )\207" [buffer-read-only unread-command-events nil undo-boundary edebug-display-freq-count append read-event undo] 3 (#$ . 99977) nil])
(defalias 'edebug-toggle #[257 "\211
J?L\210\300\301\211J#\207" [message "%s: %s"] 5 "\n\n(fn VARIABLE)"])
(require 'easymenu)
#@19 Menus for Edebug.
(defconst edebug-mode-menus '("Edebug" ["Stop" edebug-stop t] ["Step" edebug-step-mode t] ["Next" edebug-next-mode t] ["Trace" edebug-trace-mode t] ["Trace Fast" edebug-Trace-fast-mode t] ["Continue" edebug-continue-mode t] ["Continue Fast" edebug-Continue-fast-mode t] ["Go" edebug-go-mode t] ["Go Nonstop" edebug-Go-nonstop-mode t] "----" ["Help" edebug-help t] ["Abort" abort-recursive-edit t] ["Quit to Top Level" top-level t] ["Quit Nonstop" edebug-top-level-nonstop t] "----" ("Jumps" ["Forward Sexp" edebug-forward-sexp t] ["Step In" edebug-step-in t] ["Step Out" edebug-step-out t] ["Goto Here" edebug-goto-here t]) ("Breaks" ["Set Breakpoint" edebug-set-breakpoint t] ["Unset Breakpoint" edebug-unset-breakpoint t] ["Set Conditional Breakpoint" edebug-set-conditional-breakpoint t] ["Set Global Break Condition" edebug-set-global-break-condition t] ["Show Next Breakpoint" edebug-next-breakpoint t]) ("Views" ["Where am I?" edebug-where t] ["Bounce to Current Point" edebug-bounce-point t] ["View Outside Windows" edebug-view-outside t] ["Previous Result" edebug-previous-result t] ["Show Backtrace" edebug-backtrace t] ["Display Freq Count" edebug-display-freq-count t]) ("Eval" ["Expression" edebug-eval-expression t] ["Last Sexp" edebug-eval-last-sexp t] ["Visit Eval List" edebug-visit-eval-list t]) ("Options" ["Edebug All Defs" edebug-all-defs :style toggle :selected edebug-all-defs] ["Edebug All Forms" edebug-all-forms :style toggle :selected edebug-all-forms] "----" ["Tracing" (edebug-toggle 'edebug-trace) :style toggle :selected edebug-trace] ["Test Coverage" (edebug-toggle 'edebug-test-coverage) :style toggle :selected edebug-test-coverage] ["Save Windows" edebug-toggle-save-windows :style toggle :selected edebug-save-windows] ["Save Point" (edebug-toggle 'edebug-save-displayed-buffer-points) :style toggle :selected edebug-save-displayed-buffer-points])) (#$ . 100452))
(defalias 'edebug-window-live-p 'window-live-p)
(defalias 'edebug-mark #[0 "\300\301!\207" [mark t] 2 "\n\n(fn)"])
#@172 Set a conditional breakpoint at nearest sexp.
The condition is evaluated in the outside context.
With prefix argument, make it a temporary breakpoint.

(fn ARG CONDITION)
(defalias 'edebug-set-conditional-breakpoint #[514 "\300\301#\207" [edebug-modify-breakpoint t] 6 (#$ . 102491) (byte-code "\306 \211\205<\211@\211A	\307N\211A@\211\236\211A@\211\205$\310\311
\"\312\313\314@\232\2037\315\2028\316%-\266\202\262
D\207" [current-prefix-arg edebug-def-name edebug-data edebug-breakpoints edebug-break-data edebug-break-condition edebug-find-stop-point edebug format "%s" read-from-minibuffer "Condition: " t (read-expression-history . 1) read-expression-history read-expression-map] 12)])
#@14 Edebug menus
(defvar edebug-menu nil (#$ . 103207))
(byte-code "\302\303\304	$\210\305\306!\203\307\310\311\"\210\202\307\312\313\"\210\314 \210\315\316!\207" [edebug-mode-map edebug-mode-menus easy-menu-do-define edebug-menu "Edebug menus" featurep cl-read add-hook edebug-setup-hook #[0 "\300\301!\207" [require edebug-cl-read] 2 "\n\n(fn)"] cl-read-load-hooks #[0 "\300\301!\207" [require edebug-cl-read] 2 "\n\n(fn)"] edebug-install-read-eval-functions provide edebug] 5)