%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/emacs-lisp/
Current File : //usr/local/share/emacs/27.2/lisp/emacs-lisp/edebug.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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\300\302!\210\300\303!\210\304\305\306\307\310\311%\210\312\313\314\315\316\317%\210\312\320\321\322\316\317%\210\323\324\325\326\327DD\330\331\332%\210\323\333\325\326\334DD\335\331\336%\210\323\337\325\326\340DD\341\331\336%\210\323\342\325\326\343DD\344\331\336%\210\323\345\325\326\346DD\347\331\350\316\351&\210\323\352\325\326\353DD\354\331\355%\210\323\356\325\326\357DD\360\331\336%\210\323\361\325\326\362DD\363\331\364%\210\323\365\325\326\366DD\367\331\336%\210\323\370\325\326\371DD\372\331\336%\210\323\373\325\326\374DD\375\331\336%\210\323\376\325\326\377DD\201@\331\201A%\210\323\201B\325\326\201CDD\201D\331\201E%\210\323\201F\325\326\201GDD\201H\331\336%\210\323\201I\325\326\201JDD\201K\331\336%\210\323\201L\325\326\201MDD\201N\331\201O%\210\323\201P\325\326\201QDD\201R\331\336%\210\323\201S\325\326\201TDD\201U\331\201V\201W\201X&\210\323\201Y\325\326\201ZDD\201[\331\201\\%\210\323\201]\325\326\201^DD\201_\331\336\316\351&\207" [require backtrace macroexp cl-lib custom-declare-group edebug nil "A source-level debugger for Emacs Lisp." :group lisp custom-declare-face edebug-enabled-breakpoint ((t :inherit highlight)) "Face used to mark enabled breakpoints." :version "27.1" edebug-disabled-breakpoint ((((class color) (min-colors 88) (background light)) :background "#ddffdd" :extend t) (((class color) (min-colors 88) (background dark)) :background "#335533" :extend t)) "Face used to mark disabled breakpoints." custom-declare-variable edebug-setup-hook funcall function #[0 "\300\207" [nil] 1] "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] "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] "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] "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-max-depth #[0 "\300\207" [150] 1] "Maximum recursion depth when instrumenting code.\nThis limit is intended to stop recursion if an Edebug specification\ncontains an infinite loop.  When Edebug is instrumenting code\ncontaining very large quoted lists, it may reach this limit and give\nthe error message \"Too deep - perhaps infinite loop in spec?\".\nMake this limit larger to countermand that, but you may also need to\nincrease `max-lisp-eval-depth' and `max-specpdl-size'." integer "26.1" edebug-save-windows #[0 "\300\207" [t] 1] "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] "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] "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] "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] "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] "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] "If non-nil, default value of `print-length' for printing results in Edebug." (choice integer (const nil)) edebug-print-level #[0 "\300\207" [50] 1] "If non-nil, default value of `print-level' for printing results in Edebug." (choice integer (const nil)) edebug-print-circle #[0 "\300\207" [t] 1] "If non-nil, default value of `print-circle' for printing results in Edebug." edebug-unwrap-results #[0 "\300\207" [nil] 1] "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." edebug-on-error #[0 "\300\207" [t] 1] "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] "Value bound to `debug-on-quit' while Edebug is active." edebug-global-break-condition #[0 "\300\207" [nil] 1] "If non-nil, an expression to test for at every stop point.\nIf the result is non-nil, then break.  Errors are ignored." sexp :risky t edebug-sit-for-seconds #[0 "\300\207" [1] 1] "Number of seconds to pause when execution mode is `trace' or `continue'." number edebug-sit-on-break #[0 "\300\207" [t] 1] "Whether or not to pause for `edebug-sit-for-seconds' on reaching a break."] 8)
#@15 

(fn SYMBOL)
(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 (#$ . 8077)])
#@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 "\211<\203#\30027\211\203 \301@!\204\302\300\303\"\210\211A\262\202	\3040\207\2119\2057\305!?\2057\306\307\"\2057\304\207" [basic edebug-basic-spec throw nil t functionp function-get edebug-form-spec] 4 (#$ . 8257)])
#@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 (#$ . 8684)])
(defalias 'edebug-last-sexp #[0 "\300\212\301\302!\210`)`{!@\207" [read-from-string forward-sexp -1] 3])
#@54 Return a list of windows, in order of `next-window'.
(defalias 'edebug-window-list #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211\242\237\207" [nil walk-windows make-byte-code 257 "\300\300\242B\240\207" vconcat vector [] 4 "\n\n(fn W)"] 8 (#$ . 9024)])
#@23 

(fn ALIST FUNCTION)
(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 (#$ . 9300)])
#@42 Name of the buffer to put trace info in.
(defconst edebug-trace-buffer "*edebug-trace*" (#$ . 9512))
#@32 

(fn BUFFER &optional WINDOW)
(defalias 'edebug-pop-to-buffer #[513 "\301!\203\302!=\203\211\202n\302 =\203\303 \202n\304\305\"\206n\306\307!\2032\310\311 !\202n\304!\3122e\313\314\307\"\211\205b\211@\211\303 =\204[\211=\204[\315!\204[\316\312\"\210A\266\202\202=\2620\262\206n\310\311 !\262\317\"\210\320!\210\321\322 !\323>\204\207\324\322 !\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 window-list nil window-dedicated-p throw set-window-buffer select-window framep selected-frame (nil t pc) x-focus-frame set-window-hscroll] 8 (#$ . 9619)])
(defalias 'edebug-get-displayed-buffer-points #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211\242\207" [nil walk-windows make-byte-code 257 "\211\301 =?\205\300\302!\303!B\300\242B\240\207" vconcat vector [selected-window window-buffer window-point] 5 "\n\n(fn W)"] 8])
#@22 

(fn BUFFER-POINTS)
(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 (#$ . 10627)])
#@22 

(fn WHICH-WINDOWS)
(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 (#$ . 10824)])
#@20 

(fn WINDOW-INFO)
(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 (#$ . 11142)])
#@773 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 the option `edebug-all-defs' and
the option `edebug-all-forms'.

(fn ORIG &optional STREAM)
(defalias 'edebug--read #[513 "\211\204\262\211p=\203\301 \207\206\302!\207" [standard-input edebug-read-and-maybe-wrap-form read] 4 (#$ . 11579)])
#@914 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 option `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??=?\305\211?=\306 *\211@\307=\203(\211\243\243\203(\310A@!\210\202\217\211@\311=\203F\312A@!\203F\313A@\314\3158\"\"\210\202\217\211@\316=\203\217\317A@\f\"\320A@\321\305#\210\320A@\322\3238#\210\324\320\325A@D\326\325A@\327NDF\320\325A@D\330\3158FF\320A@\327\305#\210\262\314\331!\"\204\254\332	!\333	!\211\203\250\334!\210\210\202\255	)\207" [edebug-all-defs edebug-result 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 prin1 eval-expression-print-format princ] 11 (#$ . 12516) "P"])
(defalias 'edebug-defun 'edebug-eval-top-level-form)
#@813 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.)
(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 (#$ . 14300) nil])
(defvar edebug-active nil)
(defalias 'edebug-read-top-level-form #[0 "`\301\302 \210\303 \210\304 b\210)\207" [edebug-active t end-of-defun beginning-of-defun edebug-read-and-maybe-wrap-form] 3])
(defalias 'edebug-all-defuns 'edebug-all-defs)
#@39 Toggle edebugging of all definitions.
(defalias 'edebug-all-defs #[0 "?\301\302\203
\303\202\304\"\207" [edebug-all-defs message "Edebugging all definitions is %s." "on" "off"] 3 (#$ . 15561) nil])
#@33 Toggle edebugging of all forms.
(defalias 'edebug-all-forms #[0 "?\301\302\203
\303\202\304\"\207" [edebug-all-forms message "Edebugging all forms is %s." "on" "off"] 3 (#$ . 15771) nil])
(defalias 'edebug-install-read-eval-functions #[0 "\300\301\302\303B\304\305$\210\306\307\310\311#\207" [advice--add-function :around #[0 "\300\301!\207" [default-value load-read-function] 2] #[257 "\300\301\"\207" [set-default load-read-function] 4 "\n\n(fn GV--VAL)"] edebug--read nil advice-add eval-defun :override edebug-eval-defun] 5 nil nil])
(defalias 'edebug-uninstall-read-eval-functions #[0 "\300\301\302!\303\"\211\301\302!=\204\304\302\"\210\210\305\306\307\"\207" [advice--remove-function default-value load-read-function edebug--read set-default advice-remove eval-defun edebug-eval-defun] 4 nil 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 (#$ . 16593))
(make-variable-buffer-local 'edebug-form-data)
#@79 compiler-macro for inlining `edebug--form-data-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--form-data-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-name (progn (car cl-x))) nil] 9 (#$ . 17169)])
(put 'edebug--form-data-name 'compiler-macro 'edebug--form-data-name--cmacro)
#@67 Access slot "name" of `edebug--form-data' struct CL-X.

(fn CL-X)
(defalias 'edebug--form-data-name #[257 "\211@\207" [] 2 (#$ . 17517)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--form-data-name side-effect-free t] 4)
#@80 compiler-macro for inlining `edebug--form-data-begin'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--form-data-begin--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-begin (progn (nth 1 cl-x))) nil] 9 (#$ . 17760)])
(put 'edebug--form-data-begin 'compiler-macro 'edebug--form-data-begin--cmacro)
#@68 Access slot "begin" of `edebug--form-data' struct CL-X.

(fn CL-X)
(defalias 'edebug--form-data-begin #[257 "\211A@\207" [] 2 (#$ . 18115)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--form-data-begin side-effect-free t] 4)
#@78 compiler-macro for inlining `edebug--form-data-end'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--form-data-end--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-end (progn (nth 2 cl-x))) nil] 9 (#$ . 18362)])
(put 'edebug--form-data-end 'compiler-macro 'edebug--form-data-end--cmacro)
#@66 Access slot "end" of `edebug--form-data' struct CL-X.

(fn CL-X)
(defalias 'edebug--form-data-end #[257 "\3008\207" [2] 3 (#$ . 18707)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--form-data-end side-effect-free t] 4)
#@95 compiler-macro for inlining `edebug--make-form-data-entry'.

(fn CL-WHOLE-ARG NAME BEGIN END)
(defalias 'edebug--make-form-data-entry--cmacro #[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 (#$ . 18949)])
(put 'edebug--make-form-data-entry 'compiler-macro 'edebug--make-form-data-entry--cmacro)
#@75 Constructor for objects of type `edebug--form-data'.

(fn NAME BEGIN END)
(defalias 'edebug--make-form-data-entry #[771 "E\207" [] 6 (#$ . 19356)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\306&	\207" [function-put edebug--make-form-data-entry side-effect-free t cl-struct-define edebug--form-data nil list ((name) (begin) (end)) cl-struct-edebug--form-data-tags] 11)
#@29 

(fn ENTRY NAME BEGIN END)
(defalias 'edebug-set-form-data-entry #[1028 "\211\240\266A@\300\223\210\3018\300\223\207" [nil 2] 7 (#$ . 19757)])
(put 'edebug-set-form-data-entry 'byte-optimizer 'byte-compile-inline-expand)
#@32 

(fn PNT &optional END-POINT)
(defalias 'edebug-get-form-data-entry #[513 "\301\302\203H\303W\203H@\211A@ZA\262\303X\203C\211W\203C\2034\3048U\203C\3048X\203C\211\262\262\266\202\207" [edebug-form-data nil 999999 0 2] 11 (#$ . 19992)])
#@123 Return the edebug data symbol of the form where point is in.
If point is not inside an edebuggable form, signal an error.
(defalias 'edebug-form-data-symbol #[0 "\300`!\211@\262\206
\301\302!\207" [edebug-get-form-data-entry error "Not inside instrumented form"] 2 (#$ . 20269)])
#@18 

(fn NEW-ENTRY)
(defalias 'edebug-make-top-form-data-entry #[257 "\301!\210\211B\211\207" [edebug-form-data edebug-clear-form-data-entry] 3 (#$ . 20557)])
#@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 (#$ . 20723)])
#@19 

(fn &rest ARGS)
(defalias 'edebug-syntax-error #[128 "\300\301\"\207" [signal invalid-read-syntax] 4 (#$ . 20970)])
(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])
(defalias 'edebug-skip-whitespace #[0 "\300\301w\210g\302U\205\303\301w\210\300\301w\210\202\207" [" 	
\n\f" nil 59 "^\n"] 2])
(defalias 'edebug-read-sexp #[0 "\300 \211\301\267\2022\302p!\2025\302p!\2025\303u\210\304\305 D\2025\303u\210\306\305 D\2025\303u\210\307\305 D\2025\302p!\207" [edebug-next-token-class #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (symbol 8 string 14 quote 20 backquote 30 comma 40)) read 1 quote edebug-read-sexp \` \,] 3])
(defvar edebug-offsets nil)
(defvar edebug-offsets-stack nil)
(defvar edebug-current-offset nil)
(defvar edebug-read-objects nil)
(defvar edebug-read-dotted-list nil)
(defalias 'edebug-initialize-offsets #[0 "\301\211\207" [edebug-current-offset nil] 2])
(put 'edebug-initialize-offsets 'byte-optimizer 'byte-compile-inline-expand)
#@14 

(fn POINT)
(defalias 'edebug-store-before-offset #[257 "\211C\203AB\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 (#$ . 22567)])
#@14 

(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 (#$ . 22805)])
(defalias 'edebug-ignore-offset #[0 "\211AA\241\207" [edebug-current-offset] 2])
#@25 

(fn POINT &rest BODY)
(defalias 'edebug-storing-offsets '(macro . #[385 "\300\301\302DBB\303BB\207" [unwind-protect progn edebug-store-before-offset ((edebug-store-after-offset (point)))] 6 (#$ . 23130)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put edebug-storing-offsets edebug-form-spec (form body) function-put 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-special)))
#@15 

(fn STREAM)
(defalias 'edebug-read-storing-offsets #[257 "\302\303\216\304`!\210\305 	\236A\206\306!*\207" [edebug-read-dotted-list edebug-read-alist nil #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset edebug-next-token-class read] 3 (#$ . 23776)])
(byte-code "\300\301\302\"\210\300\303\302\"\207" [defalias edebug-read-symbol read edebug-read-string] 3)
#@15 

(fn STREAM)
(defalias 'edebug-read-quote #[257 "\300u\210\301\216\302`S!\210)\303\304!D\207" [1 #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset quote edebug-read-storing-offsets] 4 (#$ . 24171)])
#@15 

(fn STREAM)
(defalias 'edebug-read-backquote #[257 "\300u\210\301\216\302`S!\210)\303\304!D\207" [1 #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset \` edebug-read-storing-offsets] 4 (#$ . 24403)])
#@15 

(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\216\307!\210)\211\310!D\262\207" [1 \, 46 \,\. 64 \,@ #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset edebug-read-storing-offsets] 6 (#$ . 24636)])
#@181 Read from STREAM a Lisp object beginning with #.
Turn #'thing into (function thing) and handle the read syntax for
circular objects.  Let `read' read everything else.

(fn STREAM)
(defalias 'edebug-read-special #[257 "\3022\233\303u\210`g\304=\203&\303u\210\305\302\306\216\307`\310Z!\210)\311\312!D\"\210\202\221g\313Y\203\221g\314X\203\221g\313Y\203Dg\314X\203D\303u\210\2022\315`{!\203\220g\316=\203w\317\211BB\211	B\303u\210\312!\320\321#\210\305\302\211\241\262\"\266\202\220g\322=\203\220\323	\"\211:\203\217\303u\210\305\302A\"\210\210\210\211Sb\210\324!\2620\207" [read-circle edebug-read-objects return 1 39 throw #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset 2 function edebug-read-storing-offsets 48 57 string-to-number 61 nil lread--substitute-object-in-subtree t 35 assoc read] 11 (#$ . 24956)])
#@15 

(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 (#$ . 25830)])
#@15 

(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 (#$ . 26219)])
#@61 Set to t when matching after the dot in a dotted spec list.
(defvar edebug-dotted-spec nil (#$ . 26458))
#@28 

(fn EXPRESSIONS OFFSETS)
(defalias 'edebug-new-cursor #[514 "\300!\203\f\301\302\"\262B\207" [vectorp append nil] 5 (#$ . 26569)])
#@35 

(fn CURSOR EXPRESSIONS OFFSETS)
(defalias 'edebug-set-cursor #[771 "\240\210\241\210\207" [] 5 (#$ . 26714)])
(put 'edebug-set-cursor 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn CURSOR)
(defalias 'edebug-copy-cursor #[257 "\211@AB\207" [] 3 (#$ . 26906)])
#@15 

(fn CURSOR)
(defalias 'edebug-cursor-expressions #[257 "\211@\207" [] 2 (#$ . 26997)])
(put 'edebug-cursor-expressions 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn CURSOR)
(defalias 'edebug-cursor-offsets #[257 "\211A\207" [] 2 (#$ . 27169)])
(put 'edebug-cursor-offsets 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn CURSOR)
(defalias 'edebug-empty-cursor #[257 "\211@?\207" [] 2 (#$ . 27333)])
(put 'edebug-empty-cursor 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn CURSOR)
(defalias 'edebug-top-element #[257 "\211@@\207" [] 2 (#$ . 27494)])
(put 'edebug-top-element 'byte-optimizer 'byte-compile-inline-expand)
#@27 

(fn CURSOR &rest ERROR)
(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 (#$ . 27653)])
#@15 

(fn CURSOR)
(defalias 'edebug-top-offset #[257 "\211A@\207" [] 2 (#$ . 27875)])
(put 'edebug-top-offset 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn CURSOR)
(defalias 'edebug-move-cursor #[257 "\211\211@?\262\203\300\301\"\210\211@A\240\210\211AA\241\210\207" [edebug-no-match "Not enough arguments."] 4 (#$ . 28032)])
#@15 

(fn CURSOR)
(defalias 'edebug-before-offset #[257 "\211\211A\262\211:\203\211@@\202\211S\207" [] 3 (#$ . 28220)])
#@15 

(fn CURSOR)
(defalias 'edebug-after-offset #[257 "\211\211A@\262\211:\203\211A\262\202\211\207" [] 3 (#$ . 28347)])
(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)
#@236 Function to run on code after instrumentation for debugging.
The function is called with one argument, a FORM which has just
been instrumented for Edebugging, and it should return either FORM
or a replacement form to use in its place.
(defvar edebug-after-instrumentation-function 'identity (#$ . 28628))
#@251 Function to call after Edebug wraps a new definition.
After Edebug has initialized its own data, this function is
called with one argument, the symbol associated with the
definition, which may be the actual symbol defined or one
generated by Edebug.
(defvar edebug-new-definition-function 'edebug-new-definition (#$ . 28940))
#@518 Alist describing the runtime behavior of Edebug's instrumented code.
Each definition instrumented by Edebug will have a
`edebug-behavior' property which is a key to this alist.  When
the instrumented code is running, Edebug will look here for the
implementations of `edebug-enter', `edebug-before', and
`edebug-after'.  Edebug's instrumentation may be used for a new
purpose by adding an entry to this alist, and setting
`edebug-new-definition-function' to a function which sets
`edebug-behavior' for the definition.
(defvar edebug-behavior-alist '((edebug edebug-default-enter edebug-slow-before edebug-slow-after)) (#$ . 29273))
(defalias 'edebug-read-and-maybe-wrap-form #[0 "\306\307!\203\211 \210\202\310\311\"\210\210\306\211\211\211\211\211\211\211\312	\\\313\n\\\3142:\315 \262\3060\211\203C\316\317\"\210\210.	\211\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 edebug-read-and-maybe-wrap-form1 apply edebug-syntax-error edebug-&rest edebug-&optional edebug-def-name edebug-top-window-data] 11])
(defalias 'edebug-read-and-maybe-wrap-form1 #[0 "\306\211\211\211\211\211\211\211\212\307 \310=\203P\311u\210\307 \312=\203P\313p!\2629\205+\314!\262<\2056@\315=\262\205NA@\316=\205N\307 \312=\205N\313p!\262)\203\212\f\204]
\203~\317\320p!CC\"\321\322!\323!S\324!	ABC$@\262\202\247\325\326\327 #\210\330 \202\247
\203\245\317\320p!CC\"\321\322!\323!\306$\262\202\247\330 !\262,\207" [edebug-read-objects edebug-current-offset edebug-offsets-stack edebug-offsets edebug-all-defs edebug-all-forms nil edebug-next-token-class lparen 1 symbol 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 edebug-after-instrumentation-function] 11])
(defalias 'edebug-interactive-p-name #[0 "\301\302\303\"!\207" [edebug-def-name intern format "edebug-%s-interactive-p"] 4])
#@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 (#$ . 31372)])
#@14 

(fn FORMS)
(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 gensym "edebug-anon" edebug-enter quote list function lambda nil] 8 (#$ . 31627)])
#@15 

(fn OFFSET)
(defalias 'edebug-inc-offset #[257 "	Z\nBT\207" [edebug-offset-index edebug-form-begin-marker edebug-offset-list] 4 (#$ . 31921)])
#@38 

(fn BEFORE-INDEX FORM AFTER-INDEX)
(defalias 'edebug-make-before-and-after-form #[771 "\300\301DF\207" [edebug-after edebug-before] 7 (#$ . 32077)])
#@25 

(fn FORM AFTER-INDEX)
(defalias 'edebug-make-after-form #[514 "\300\301F\207" [edebug-after 0] 6 (#$ . 32237)])
#@284 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.
Does not unwrap inside vectors, records, structures, or hash tables.

(fn SEXP)
(defalias 'edebug-unwrap #[257 "\211:\203\323\211@\211\300\267\202\321A\211:\203L\211@A\211:\203F\211@A\211:\203?\211@A\211\2048\266\203\202:\266\202\202A\266\202\202G\266\202\202M\262\202\322A\211:\203\211\211@A\211:\203\203\211@\211:\203}\211@\211\301=\203vA\211:\203o\211@\211:\203h\211@\211\302=\203aA\211:\203Z\211@A\211\204SA\211:\203L\211@A\211:\203E\211@\211:\203>\211@\211\303=\2037A\211:\2030\211@\211:\203)\211@\211\304=\203\"A\211:\203\211@\211\204AA\211\204
	A\211\204A\211\204\377
\304BB\266\204\202\262\202\262\202\266\202\202\262\202\262\202$\262\202+\262\2022\262\2029\262\202@\262\202G\266\202\202N
\262\202U\f\266\202\202\\\n\262\202c	\262\202j\262\202q\262\202x\262\202~\262\202\204\266\202\202\212\262\202\322A\211:\203\334\211@A\211:\203\326\211@A\211:\203\317\211@\211:\203\310\211@\211\301=\203\301A\211:\203\272\211@\211:\203\263\211@\211\302=\203\254A\211:\203\245\211@A\211\204\236A\211:\203\227\211@A\211:\203\220\211@\211:\203\211\211@\211\303=\203\202A\211:\203{\211@\211:\203t\211@\211\304=\203mA\211:\203f\211@\211\204_AA\211\204X	A\211\204QA\211\204J
\305BBB\266\205\202L\262\202S\262\202Z\266\202\202a\262\202h\262\202o\262\202v\262\202}\262\202\204\262\202\213\262\202\222\266\202\202\231\262\202\240\266\202\202\247\f\262\202\256\262\202\265\n\262\202\274	\262\202\303\262\202\312\262\202\321\266\202\202\327\266\202\202\335\262\202\322A\211:\203\313\211@\211:\203\305\211@\211\302=\203\277A\211:\203\271\211@A\211\204\262A\211:\203\253\211@A\211:\203\244\211@\211:\203\235\211@\211\303=\203\226A\211:\203\217\211@\211:\203\210\211@\211\304=\203\201A\211:\203z\211@\211\204sAA\211\204l	A\211\204e\f\306!\266\203\202g\262\202n\266\202\202u\262\202|\262\202\203\262\202\212\262\202\221
\262\202\230\f\262\202\237\262\202\246\n\266\202\202\255\262\202\264\266\202\202\272\262\202\300\262\202\306\262\202\314\262\202\322\207\207" [#s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (edebug-after 13 lambda 82 closure 399 edebug-enter 738)) edebug-enter quote function lambda closure macroexp-progn] 38 (#$ . 32360)])
#@51 Return the SEXP recursively unwrapped.

(fn SEXP)
(defalias 'edebug-unwrap* #[257 "\300\301\302\"\303\"\207" [make-hash-table :test eq edebug--unwrap1] 5 (#$ . 35099)])
#@236 Unwrap SEXP using HASH-TABLE of things already unwrapped.
HASH-TABLE contains the results of unwrapping cons cells within
SEXP, which are reused to avoid infinite loops when SEXP is or
contains a circular object.

(fn SEXP HASH-TABLE)
(defalias 'edebug--unwrap1 #[514 "\300!=\204\211\262\300!\262\202\211:\203\201\301\302#\211\204{\302\211\211B\262\262\303#\210\211\211\304@\"\240\266A\262:\204T\211\211\304\"\241\266\202y\301\302#\203k\211\211\301\302#\241\266\202y\211\211\302\211B\241\262\211\262\204,\266\211\262\202\202\211\207" [edebug-unwrap gethash nil puthash edebug--unwrap1] 12 (#$ . 35277)])
#@44 

(fn CURSOR FORM-BEGIN FORM-END SPECLIST)
(defalias 'edebug-defining-form #[1028 "\211\211@\262\211A\262A\240\210\241\210\266\300S$\207" [edebug-make-form-wrapper] 9 (#$ . 35937)])
#@54 

(fn CURSOR FORM-BEGIN FORM-END &optional SPECLIST)
(defalias 'edebug-make-form-wrapper #[1027 "\306\"\211\203\211A@\202\307 \310\223\310\311\310@\310\211\211\211\2035\312\"\202<\313\314	!C!\262\f\206I
\206I\315\316!\204a\f\307 \310\223E\266\203\262\202|\f\211\240\266A@\310\223\210\3178\310\223\266\320!\210\321\237!\322\f!\210\323\f!\210\204\244\324p!\206\234\325 \211\326!B\210\327\f\330\331
!F#\210\f!\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 cl-gensym "edebug-anon" 2 edebug-make-top-form-data-entry vconcat edebug-clear-frequency-count edebug-clear-coverage get-buffer-window selected-window window-start put edebug edebug--restore-breakpoints edebug-offset-index edebug-offset-list edebug-top-window-data edebug-new-definition-function] 15 (#$ . 36139)])
#@13 

(fn NAME)
(defalias 'edebug--restore-breakpoints #[257 "\211\300N\211<\205N\3018A@@\302\302\211\211:\203H@\262\3038\262\304!\203A\305\304!Z\"\211\262\203AABB\262A\262\202\211\237\266\204\266\204\207" [edebug 2 nil 3 marker-position seq-position] 14 (#$ . 37177)])
#@75 Set up DEF-NAME to use Edebug's instrumentation functions.

(fn DEF-NAME)
(defalias 'edebug-new-definition #[257 "\300\301\302#\210\303\304\"\207" [put edebug-behavior edebug message "Edebug: %s"] 5 (#$ . 37477)])
#@13 

(fn NAME)
(defalias 'edebug-clear-frequency-count #[257 "\301\302\303G\304\"#\207" [edebug-offset-list put edebug-freq-count make-vector 0] 7 (#$ . 37699)])
#@13 

(fn NAME)
(defalias 'edebug-clear-coverage #[257 "\301\302\303G\304\"#\207" [edebug-offset-list put edebug-coverage make-vector edebug-unknown] 7 (#$ . 37866)])
#@15 

(fn CURSOR)
(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 (#$ . 38037)])
#@15 

(fn CURSOR)
(defalias 'edebug-forms #[257 "\300\301\"\207" [edebug-match (&rest form)] 4 (#$ . 38635)])
(put 'edebug-forms 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn CURSOR)
(defalias 'edebug-sexps #[257 "\300\301\"\207" [edebug-match (&rest sexp)] 4 (#$ . 38812)])
(put 'edebug-sexps 'byte-optimizer 'byte-compile-inline-expand)
#@20 

(fn HEAD CURSOR)
(defalias 'edebug-list-form-args #[514 "\304!\235\203!	\203\305\306\"\262\202\200\305\307\"\262\202\200\211\203[\211:\2036\310\211\311\"*\202\200\211\312\267\202P\305\306\"\262\202\200\305\307\"\262\202\200\2119\205\200\211!\202\200\313!\203y	\203o\305\306\"\262\202\200\305\307\"\262\202\200\305\306\"\262\207" [edebug--cl-macrolet-defs edebug-eval-macro-args edebug-error-point edebug-best-error get-edebug-spec edebug-match (&rest form) (&rest sexp) nil edebug-match-sublist #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 60 0 70)) macrop] 7 (#$ . 38989)])
(put 'edebug-list-form-args 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn CURSOR)
(defalias 'edebug-list-form #[257 "\304\305\"\306\307\211\211\211@\262\211A\262A\240\210\241\210\266\2119\203J\211\204.\307\202h\211\310=\203?\311\312!\210\313 \202h\211\314\312!\"B\202h\211:\203e\211@\315=\203]\316\317\"\202h\320\321\320#\202h\322\323!+\207" [edebug-&rest edebug-&optional edebug-gate edebug-def-interactive edebug-top-element-required "Expected elements" t nil interactive-p check-it edebug-move-cursor edebug-interactive-p-name #[514 "\304!\235\203!	\203\305\306\"\262\202\200\305\307\"\262\202\200\211\203[\211:\2036\310\211\311\"*\202\200\211\312\267\202P\305\306\"\262\202\200\305\307\"\262\202\200\2119\205\200\211!\202\200\313!\203y	\203o\305\306\"\262\202\200\305\307\"\262\202\200\305\306\"\262\207" [edebug--cl-macrolet-defs edebug-eval-macro-args edebug-error-point edebug-best-error get-edebug-spec edebug-match (&rest form) (&rest sexp) nil edebug-match-sublist #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 60 0 70)) macrop] 7 "\n\n(fn HEAD CURSOR)"] \, edebug-match (("," def-form) body) edebug-match-specs (lambda-expr body) edebug-syntax-error "Head of list form must be a symbol or lambda expression"] 7 (#$ . 39735)])
(defvar edebug-matching-depth 0)
#@26 

(fn CURSOR &rest ARGS)
(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 (#$ . 41062)])
#@21 

(fn CURSOR SPECS)
(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 (#$ . 41362)])
#@20 

(fn CURSOR SPEC)
(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 (#$ . 41580)])
#@39 

(fn CURSOR SPECS REMAINDER-HANDLER)
(defalias 'edebug-match-specs #[771 "	V\203\f\303\304!\202T\204\305\202\301:\204(\306\307C#)\202\301\211@\262<\204?\310@!\204?@\311>\203\220@\3059\205L\312!\313H\211\314\267\202p\315!A\"\202yAA\262\315!A@\"\202yA\262\316\"\211<\203\212\211#\244\202\213\211\266\204\202\301\n\204\231\317\320\"\210\305\211@\262\211A\262C\240\210\241\210\266\307#@)\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 vectorp (&optional &rest) symbol-name 0 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (38 82 58 94)) get-edebug-spec edebug-match-one-spec edebug-no-match "Dotted spec required."] 12 (#$ . 41861)])
(byte-code "\300\211\203\211@\301@\302A#\210A\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) (cl-generic-method-args . edebug-match-cl-generic-method-args) (cl-macrolet-expr . edebug-match-cl-macrolet-expr) (cl-macrolet-name . edebug-match-cl-macrolet-name) (cl-macrolet-body . edebug-match-cl-macrolet-body) (&not . edebug-match-&not) (&key . edebug-match-&key) (place . edebug-match-place) (gate . edebug-match-gate)) put edebug-form-spec] 6)
#@22 

(fn CURSOR SYMBOL)
(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 (#$ . 43543)])
#@15 

(fn CURSOR)
(defalias 'edebug-match-sexp #[257 "\300\301\"\302!\210C\207" [edebug-top-element-required "Expected sexp" edebug-move-cursor] 4 (#$ . 44036)])
#@15 

(fn CURSOR)
(defalias 'edebug-match-form #[257 "\300!C\207" [edebug-form] 3 (#$ . 44202)])
(defalias 'edebug-match-place 'edebug-match-form)
#@15 

(fn CURSOR)
(defalias 'edebug-match-body #[257 "\211\300\301\"\207" [edebug-match (&rest form)] 5 (#$ . 44352)])
(put 'edebug-match-body 'byte-optimizer 'byte-compile-inline-expand)
#@21 

(fn CURSOR SPECS)
(defalias 'edebug-match-&optional #[514 "\300\300#\207" [edebug-&optional-wrapper] 6 (#$ . 44543)])
#@39 

(fn CURSOR SPECS REMAINDER-HANDLER)
(defalias 'edebug-&optional-wrapper #[771 "\302\302\211@\262\211A\262\3032\"\304#\262\3020\204)\2029\240\210\241\210\266\302*\207" [edebug-gate edebug-&optional nil no-match edebug-match-specs] 13 (#$ . 44671)])
#@39 

(fn CURSOR SPECS REMAINDER-HANDLER)
(defalias 'edebug-&rest-wrapper #[771 "\204\262\301#\207" [edebug-&rest edebug-&optional-wrapper] 7 (#$ . 44958)])
#@21 

(fn CURSOR SPECS)
(defalias 'edebug-match-&rest #[514 "\211\303\211\304\304#+\207" [edebug-error-point edebug-best-error edebug-&rest nil edebug-&rest-wrapper] 6 (#$ . 45125)])
#@21 

(fn CURSOR SPECS)
(defalias 'edebug-match-&or #[514 "\211\211@\262\211A\262\3032H\203?\3042)\305\303\306\211\211\307@\"+\"0\210A\262\240\210\241\210\266\202\310\311\312$0\207" [edebug-error-point edebug-best-error edebug-gate matched no-match throw nil edebug-match-one-spec apply edebug-no-match "Expected one of"] 10 (#$ . 45315)])
#@21 

(fn CURSOR SPECS)
(defalias 'edebug-match-&not #[514 "\3012\302\212\303\"\210*\3020\204\304\305\"\210\302\207" [edebug-gate no-match nil edebug-match-&or edebug-no-match "Unexpected"] 5 (#$ . 45689)])
(put '&key 'edebug-form-spec 'edebug-match-&key)
#@21 

(fn CURSOR SPECS)
(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 (#$ . 45955)])
#@15 

(fn CURSOR)
(defalias 'edebug-match-gate #[257 "\301\302\207" [edebug-gate t nil] 2 (#$ . 46170)])
#@21 

(fn CURSOR SPECS)
(defalias 'edebug-match-list #[514 "\203\302\303\303#)\302\207\211@\304\305#\306\267\202nA@\2119\203:\211=\2040\307\305#\210\310!\210\311\202>\312\313\"\262\202\216\314!\203f\315\316\211A@\262A\"A\"\310!\210\317\320\"C\262\202\216\307\305#\202\216\211<\203\211\315\316\211A@\262A\"\"C\310!\210\202\216\307\305#\207" [edebug-dotted-spec edebug-gate nil edebug-match-specs edebug-top-element-required "Expected" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (quote 28 vector 67)) edebug-no-match edebug-move-cursor t error "Bad spec: %s" vectorp edebug-match-sublist edebug-new-cursor apply vector] 9 (#$ . 46278)])
#@21 

(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 (#$ . 47005)])
#@20 

(fn CURSOR SPEC)
(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 (#$ . 47271)])
#@15 

(fn CURSOR)
(defalias 'edebug-match-nil #[257 "\211\211@?\262?\205\300\301\"\207" [edebug-no-match "Unmatched argument(s)"] 4 (#$ . 47516)])
#@15 

(fn CURSOR)
(defalias 'edebug-match-function #[257 "\300\301!\207" [error "Use function-form instead of function in edebug spec"] 3 (#$ . 47669)])
#@21 

(fn CURSOR SPECS)
(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 (#$ . 47824)])
#@15 

(fn CURSOR)
(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 (#$ . 48021)])
#@15 

(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 (#$ . 48464)])
#@20 

(fn CURSOR SPEC)
(defalias 'edebug-match-colon-name #[514 "\203\301\302\303#!\202\211\304\207" [edebug-def-name intern format "%s@%s" nil] 7 (#$ . 48789)])
#@15 

(fn CURSOR)
(defalias 'edebug-match-cl-generic-method-args #[257 "\301\302\"\211:\204\303\304\"\210\305\306\307#!\310!\210\211C\207" [edebug-def-name edebug-top-element-required "Expected arguments" edebug-no-match "List expected" intern format "%s %s" edebug-move-cursor] 7 (#$ . 48961)])
#@77 List of symbols found within the bindings of enclosing `cl-macrolet' forms.
(defvar edebug--cl-macrolet-defs nil (#$ . 49267))
#@78 List of symbols found within the bindings of the current `cl-macrolet' form.
(defvar edebug--current-cl-macrolet-defs nil (#$ . 49400))
#@52 Match a `cl-macrolet' form at CURSOR.

(fn CURSOR)
(defalias 'edebug-match-cl-macrolet-expr #[257 "\301\302\303\")\207" [edebug--current-cl-macrolet-defs nil edebug-match ((&rest (&define cl-macrolet-name cl-macro-list cl-declarations-or-string def-body)) cl-declarations cl-macrolet-body)] 4 (#$ . 49542)])
#@207 Match the name in a `cl-macrolet' binding at CURSOR.
Collect the names in `edebug--cl-macrolet-defs' where they
will be checked by `edebug-list-form-args' and treated as
macros without a spec.

(fn CURSOR)
(defalias 'edebug-match-cl-macrolet-name #[257 "\302\303\"\2119\204\304\305#\210\306\307!\310!\210\211	B\211C\207" [edebug-def-name edebug--current-cl-macrolet-defs edebug-top-element-required "Expected name" edebug-no-match "Bad name:" gensym "edebug-anon" edebug-move-cursor] 6 (#$ . 49859)])
#@215 Match the body of a `cl-macrolet' expression at CURSOR.
Put the definitions collected in `edebug--current-cl-macrolet-defs'
into `edebug--cl-macrolet-defs' which is checked in `edebug-list-form-args'.

(fn CURSOR)
(defalias 'edebug-match-cl-macrolet-body #[257 "	\244\211\211\302\303\"\266\202)\207" [edebug--current-cl-macrolet-defs edebug--cl-macrolet-defs edebug-match (&rest form)] 6 (#$ . 50375)])
#@15 

(fn CURSOR)
(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 (#$ . 50787)])
#@15 

(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 (#$ . 51076)])
#@15 

(fn CURSOR)
(defalias 'edebug-match-def-body #[257 "\301\211\302\303\"\262\211\205\304!C)\207" [edebug-inside-func t edebug-match (&rest form) edebug-wrap-def-body] 5 (#$ . 51241)])
#@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 (#$ . 51437)])
(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\337#\210\300\340\302\336#\210\300\341\302\342#\210\300\343\302\344#\210\300\345\302\346#\210\300\347\302\350#\210\300\351\302\352#\210\300\353\302\354#\210\355\356\347\"\210\300\356\302\357#\210\300\360\302\361#\210\300\362\302\363#\210\300\364\302\365#\210\300\366\302\365#\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 lambda-doc [&optional ("declare" &rest sexp)] [&optional ("interactive" interactive)] def-body) defmacro (&define name lambda-list lambda-doc [&optional ("declare" &rest sexp)] def-body) arglist lambda-list (([&rest arg] [&optional ["&optional" arg &rest arg]] &optional ["&rest" arg])) lambda-doc (&optional [&or stringp (&define ":documentation" def-form)]) 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) cond (&rest (&rest form)) condition-case (symbolp form &rest ([&or symbolp (&rest symbolp)] body)) \` (backquote-form) backquote-form (&or ("`" nested-backquote-form) ([&or "," ",@"] &or ("quote" backquote-form) form) (backquote-form [&rest [&not ","] backquote-form] . [&or nil backquote-form]) (vector &rest backquote-form) sexp) nested-backquote-form (&or ([&or "," ",@"] backquote-form) (nested-backquote-form [&rest [&not "," ",@"] nested-backquote-form] . [&or nil nested-backquote-form]) (vector &rest nested-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-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 (#$ . 54311)])
#@300 Enter Edebug for a function.
FUNC should be the symbol with the Edebug information, ARGS is
the list of arguments and BODY is the code.

Look up the `edebug-behavior' for FUNC in `edebug-behavior-alist'
and run its entry function, and set up `edebug-before' and
`edebug-after'.

(fn FUNC ARGS BODY)
(defalias 'edebug-enter #[771 "\301N\302\"A\211A@\303K\304\305\306\307\310!\311\"\312$\216\303M\210\3128\313K\304\305\306\307\310!\314\"\312$\216\313M\210@			#)\266\202)\266\202\262\207" [edebug-behavior-alist edebug-behavior assoc edebug-before make-byte-code 0 "\301\300M\207" vconcat vector [edebug-before] 2 edebug-after [edebug-after]] 15 (#$ . 55183)])
#@27 

(fn FUNCTION ARGS BODY)
(defalias 'edebug-default-enter #[771 "	\204]\306\307\n\\\310\\\f
\311 
\206 !\"\312\313\314\315\316!\317\"\320$\216\321#$\206I%\206I&&\322$\323\n\n\n#.\n\266\207\202\252\324N\211'@(\325N\326N\327(!)*B*\313+B+\330N\203\231\331&\330N\332=\203\231\333\330\322#\210,\203\246\334#\202\250\211 .)\207" [edebug-function edebug-entered max-lisp-eval-depth max-specpdl-size edebug-debugger debug-on-error t 100 200 selected-frame make-byte-code 0 "\301\300!\205\302\300!\303>?\205\304\300!\207" vconcat vector [frame-live-p framep (nil t pc) x-focus-frame] 2 edebug-signal nil edebug-default-enter edebug edebug-freq-count edebug-coverage marker-buffer edebug-on-entry step temp put edebug--enter-trace debug-on-quit edebug-on-error edebug-on-quit 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] 17 (#$ . 55860)])
#@389 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), or nil (if the default binding is current).

(fn VAR)
(defalias 'edebug-var-status #[257 "\300!JB\207" [variable-binding-locus] 3 (#$ . 56974)])
#@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.rq\210L)\202.\302!\203+\303BC\"\202.L\207" [bufferp buffer-live-p framep modify-frame-parameters] 8 (#$ . 57462)])
#@27 

(fn FUNCTION ARGS BODY)
(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 (#$ . 57767)])
(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 (#$ . 58101)]))
#@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 (#$ . 58541)])
#@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 (#$ . 58830)])
#@21 

(fn BEFORE-INDEX)
(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 (#$ . 59116)])
#@21 

(fn BEFORE-INDEX)
(defalias 'edebug-fast-before #[257 "\300\207" [nil] 2 (#$ . 59412)])
#@39 

(fn BEFORE-INDEX AFTER-INDEX VALUE)
(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 (#$ . 59508)])
#@39 

(fn BEFORE-INDEX AFTER-INDEX VALUE)
(defalias 'edebug-fast-after #[771 "\207" [] 4 (#$ . 59875)])
#@34 Set up Edebug's normal behavior.
(defalias 'edebug-run-slow #[0 "\301\236\211\302\241\207" [edebug-behavior-alist edebug (edebug-default-enter edebug-slow-before edebug-slow-after)] 3 (#$ . 59981)])
#@47 Disable Edebug without de-instrumenting code.
(defalias 'edebug-run-fast #[0 "\301\236\211\302\241\207" [edebug-behavior-alist edebug (edebug-default-enter edebug-fast-before edebug-fast-after)] 3 (#$ . 60187)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\207" [defalias edebug-before nil "Function called by Edebug before a form is evaluated.\nSee `edebug-behavior-alist' for implementations." edebug-after "Function called by Edebug after a form is evaluated.\nSee `edebug-behavior-alist' for implementations."] 4)
#@26 

(fn AFTER-INDEX VALUE)
(defalias 'edebug--update-coverage #[514 "H\211\301=\206!\211\302=\203I\202!=?\205!\301I\207" [edebug-coverage edebug-ok-coverage edebug-unknown] 6 (#$ . 60718)])
(defvar edebug-break-result nil)
(defvar edebug-global-break-result nil)
#@36 

(fn OFFSET-INDEX ARG-MODE VALUE)
(defalias 'edebug-debugger #[771 "\203\207	A@\n\236\211A@\3068
\205(\3071&\310
!\2110\202(\210\311\311\206F\205F\211?\205F\f?\206F\310\f!\211\211\203]\3128\203]	\313\n\"	AAB\241\210\314>\203n\204n\315 \203t\316#\210-\207" [inhibit-redisplay edebug-data edebug-breakpoints edebug-break-data edebug-break-condition edebug-global-break-condition 4 (error) edebug-eval nil 2 delq (go continue Continue-fast) input-pending-p edebug--display edebug-global-break-result edebug-global-break edebug-break edebug-break-result edebug-execution-mode] 9 (#$ . 60999)])
(defvar edebug-eval-list nil)
(defvar edebug-previous-result nil)
(defalias 'edebug-mark-marker 'mark-marker)
#@36 

(fn VALUE OFFSET-INDEX ARG-MODE)
(defalias 'edebug--display #[771 "\212\300#)\207" [edebug--display-1] 7 (#$ . 61749)])
#@36 

(fn VALUE OFFSET-INDEX ARG-MODE)
(defalias 'edebug--display-1 #[771 "\306!\204	\307 \210\310\311 \312\313	8H\\\312\314	8\315 p`\316 \312\211C\312\n\205)\317 \312C\312C\320\321!@AB\nC\fDE\322\323\324\325\326!\327\"\314$\216\312\211FG\330\321\310\"\210\331H!\204r\332\333I\"\210\334=\203~\335!\210J\203\210\336J!K\203\222\337 \240\210\340HC@\"\210C\315 \240\210\341!\210\342C@!\210\343\344 !\345>\204\270\346\344 !\210Hq\210`\262\fDb\210\347=\203\326g\350>\204\326\332\351I\"\210LMML\352 \210\353=\203\354N\352 \210\355 \210@\356=\203\357\360!\210\202B\361!\210\202BO\203>P\203\357\362QR#\210\202BS\203-\357\363ST#\210\202BN\364=\204B\357\365!\210\202B\202B\357\366!\210\334=\203bO\203_U\203_N\364=\204_\367V!\210\370 \210O\203\203N\371\267\202}\367V!\210\202\267\367\323!\210\202\267\310\262\202\267N\372\267\202\231\367V!\210\202\267\367\323!\210\202\267O\203\267N\373\267\202\264\367V!\210\202\267\367\323!\210\202\267\310\262\374 \203\305\310\262\354N\375 \210\352 \210\322\323\376\325\326\n$\377\"\201W$\216
\204\362N\201X>\204\362\353=\203\371\201Y!\210+rHq\210b.
\207" [edebug-def-mark edebug-data edebug-eval-list edebug-outside-d-c-i-n-s-w edebug-eval-buffer edebug-outside-windows 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 make-byte-code 0 "	\203\303	!\210\304\300!\210\305\306\n\"\207" vconcat vector [edebug-eval-buffer edebug-outside-d-c-i-n-s-w kill-buffer with-timeout-unsuspend set-default cursor-in-non-selected-windows] set-default buffer-name user-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 framep selected-frame (nil t pc) x-focus-frame before (40 35 96) "Source has changed - reevaluate definition of %s" edebug-overlay-arrow error step beep quit message "Quit" edebug-report-error "Global Break: %s => %s" "Break: %s => %s" Continue-fast "Break" "" sit-for edebug-previous-result #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (continue 366 Continue-fast 374)) #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (trace 394 Trace-fast 402)) #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (continue 421 Continue-fast 429)) input-pending-p edebug-stop "\306 \f=\203\f\307 \202\310\f!\211\203
\240\210
\311!\241\210\210\302\310!\240\210\302\242\2036\303\302\242\2054\311\302\242!\240\210\203p\312!\210\203J\313\301\242!\210\302\242\203V\314\302\242\303\242\"\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] edebug-outside-mark edebug-outside-point edebug-outside-buffer edebug-window-data edebug-point edebug-active unread-command-events cursor-in-echo-area edebug-buffer edebug-function edebug-save-windows edebug-save-displayed-buffer-points overlay-arrow-position overlay-arrow-string edebug-execution-mode edebug-break edebug-global-break edebug-global-break-condition edebug-global-break-result edebug-break-condition edebug-break-result edebug-sit-on-break edebug-sit-for-seconds 5 (step next) edebug--recursive-edit] 28 (#$ . 61880)])
(defvar edebug-number-of-recursions 0)
(defvar edebug-recursion-depth 0)
#@17 

(fn ARG-MODE)
(defalias 'edebug--recursive-edit #[257 "rq\210\306 )\307 \310\211\211\211\311\216\310\211\211\211\211\211\312\211\205)\310\211\313BC\205; !\"#$%&'()\314=\203n\211\315>\204n\316\317!\210\310*\313\320!\210\321\216\322 .\207" [edebug-outside-buffer edebug-inside-windows edebug-backtrace-buffer edebug-interactive-p edebug-entered edebug-recursion-depth match-data recursion-depth nil #[0 "\300\207" [nil] 1] t edebug-mode go (after error) message "Break" 1 #[0 "\305	\203\n\306	!\210\307\n!\210\310!\203(q\210\f\311>\203$\312 \210\313\314!\210\315\316!\207\317\320!\207" [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 sit-for 0 edebug-mode -1 get-buffer-create " bogus edebug buffer"] 2] recursive-edit edebug-outside-match-data last-command this-command edebug-continue-kbd-macro executing-kbd-macro edebug-mode-map edebug-outside-debug-on-error edebug-outside-debug-on-quit defining-kbd-macro debug-on-quit debug-on-error minor-mode-overriding-map-alist overriding-terminal-local-map overriding-local-map standard-input standard-output track-mouse last-nonmenu-event last-event-frame last-command-event last-input-event current-prefix-arg edebug-execution-mode signal-hook-function] 18 (#$ . 65886)])
#@50 Association list of arrows for each edebug mode.
(defconst edebug-arrow-alist '((Continue-fast . "=") (Trace-fast . "-") (continue . ">") (trace . "->") (step . "=>") (next . "=>") (go . "<>") (Go-nonstop . "..")) (#$ . 67325))
(defalias 'edebug-overlay-arrow #[0 "\304 	\236A\305 \211p\223\207" [edebug-execution-mode edebug-arrow-alist overlay-arrow-string overlay-arrow-position line-beginning-position make-marker] 5])
#@174 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.
(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 (#$ . 67759) nil])
#@19 

(fn &rest BODY)
(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 (#$ . 68216)]))
#@182 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.
(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 (#$ . 68610) 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 (#$ . 69296) "P"])
#@61 Show the debug windows and where we stopped in the program.
(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 (#$ . 69605) nil])
#@75 Change to the outside window configuration.
Use `edebug-where' to return.
(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 (#$ . 69853) 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$\216\317	!\210\nb\210\320\321p`\322\323 !\2030\324\323 !\2021\325$\210\326!\210\317\f@\")\262)\207" [edebug-active edebug-outside-buffer edebug-outside-point edebug-buffer edebug-window-data error "Edebug is not active" current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 edebug-pop-to-buffer message "Current buffer: %s Point: %s Mark: %s" marker-buffer edebug-mark-marker marker-position "<not set>" sit-for] 8 (#$ . 70356) "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])
#@65 Move point to the next breakpoint, or first if none past point.
(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 (#$ . 71591) 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\205s\211@\211A\305N\211@	A@\306	8\nH\\\307\236\262\310\"\203Y\311\312 \307\223\307\257B\313\"\203Q\314\315	#\210\202i\314\316\"\210\202i\211\203e\314\317\"\210\202i\314\320!\210	A\240\210b,\266\204\207" [edebug-def-name edebug-data edebug-def-mark edebug-breakpoints edebug-find-stop-point edebug 2 nil delq edebug-sort-alist make-marker < message "Breakpoint set in %s with condition: %s" "Breakpoint set in %s" "Breakpoint unset in %s" "No breakpoint here"] 16 (#$ . 72191)])
#@101 Set the breakpoint of nearest sexp.
With prefix argument, make it a temporary breakpoint.

(fn ARG)
(defalias 'edebug-set-breakpoint #[257 "\204\301`!\211@\262\302N\211?\206\303!\262\203\304 \210\305\306\307#\207" [edebug-active edebug-get-form-data-entry edebug markerp edebug-defun edebug-modify-breakpoint t nil] 5 (#$ . 73019) "P"])
#@39 Clear the breakpoint of nearest sexp.
(defalias 'edebug-unset-breakpoint #[0 "\300\301!\207" [edebug-modify-breakpoint nil] 2 (#$ . 73373) nil])
#@48 Unset all the breakpoints in the current form.
(defalias 'edebug-unset-breakpoints #[0 "\300 \211\301NA@\211\204\302\303\"\210\212\211\211\205(\211@\3048b\210\305\306!\210A\266\202\202\262)\207" [edebug-form-data-symbol edebug user-error "There are no breakpoints in %s" 3 edebug-modify-breakpoint nil] 6 (#$ . 73524) nil])
#@55 Toggle whether the breakpoint near point is disabled.
(defalias 'edebug-toggle-disable-breakpoint #[0 "\300 \211\204\n\301\302!\210\211@A\303NA@\236\211\204\301\304!\210\305\233\211\3058?\240\262\266\204\207" [edebug-find-stop-point user-error "No stop point near point" edebug "No breakpoint near point" 4] 9 (#$ . 73863) 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 (#$ . 74208) (byte-code "\205\303\304\"\305\306	\307\n@\232\203\310\202\302%\262C\207" [edebug-global-break-condition read-expression-map read-expression-history format "%s" read-from-minibuffer "Global Condition: " t (read-expression-history . 1)] 8)])
#@26 

(fn MODE SHORTMSG MSG)
(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 (#$ . 74649)])
(defalias 'edebug-step-through-mode 'edebug-step-mode)
#@29 Proceed to next stop point.
(defalias 'edebug-step-mode #[0 "\300\301\302\303#\207" [edebug-set-mode step "" "Edebug will stop at next stop point."] 4 (#$ . 74968) nil])
#@37 Proceed to next `after' stop point.
(defalias 'edebug-next-mode #[0 "\300\301\302\303#\207" [edebug-set-mode next "" "Edebug will stop after next eval."] 4 (#$ . 75144) 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 (#$ . 75326) "P"])
#@95 Go, evaluating without debugging.
You can use `edebug-stop', or any editing command, to stop.
(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 (#$ . 75615) nil])
#@75 Begin trace mode.
Pauses for `edebug-sit-for-seconds' at each stop point.
(defalias 'edebug-trace-mode #[0 "\300\301\302\303#\207" [edebug-set-mode trace "Tracing..." "Edebug will trace with pause."] 4 (#$ . 75877) nil])
#@94 Trace with no wait at each step.
Updates the display at each stop point, but does not pause.
(defalias 'edebug-Trace-fast-mode #[0 "\300\301\302\303#\207" [edebug-set-mode Trace-fast "Trace fast..." "Edebug will trace without pause."] 4 (#$ . 76104) nil])
#@79 Begin continue mode.
Pauses for `edebug-sit-for-seconds' at each break point.
(defalias 'edebug-continue-mode #[0 "\300\301\302\303#\207" [edebug-set-mode continue "Continue..." "Edebug will pause at breakpoints."] 4 (#$ . 76366) nil])
#@95 Trace with no wait at each step.
Updates the display at each break point, but does not pause.
(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 (#$ . 76608) nil])
#@68 Proceed to first stop-point at or after current position of point.
(defalias 'edebug-goto-here #[0 "\300\301!\207" [edebug-go-mode t] 2 (#$ . 76887) nil])
#@85 Stop execution and do not continue.
Useful for exiting from trace or continue loop.
(defalias 'edebug-stop #[0 "\300\301!\207" [message "Stop"] 2 (#$ . 77048) 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 "\3011\302\303!\210\304\302!)0\207\210\305 \207" [parse-sexp-ignore-comments (error) t forward-sexp edebug-go-mode edebug-step-out] 3 (#$ . 77220) "p"])
#@204 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.
(defalias 'edebug-step-out #[0 "\3011\302\303\304!\210\212\303\304!\210)\305\302!)0\207\210`\306\307!\210`U\203'\310 \202*\305\302!\207" [parse-sexp-ignore-comments (error) t up-list 1 edebug-go-mode down-list -1 edebug-step-mode] 3 (#$ . 77559) nil])
#@287 Instrument the function or generic method FUNC.
Return the list of function symbols which were instrumented.
This may be simply (FUNC) for a normal function, or a list of
generated symbols for methods.  If a function or method to
instrument cannot be found, signal an error.

(fn FUNC)
(defalias 'edebug-instrument-function #[257 "\211\300N\301!\203U\302!\303\204\304\305\"\210\211\203O\211@\211@A\211\306\307#\211A\2042\304\310\"\210r\211@q\210\211Ab\210\311 \210\312 B\262)\266A\266\202\202\210\262\202\240\313!\203s\314!\203sr\314!q\210\211b\210\311 \210)C\202\240\211:\203\202\315\316\"\210C\202\240\317\320\"\211A\204\217\304\321!\210r\211@q\210\211Ab\210\311 \210)C\262\207" [edebug cl-generic-p cl--generic-method-files nil error "Could not find any method definitions for %s" find-function-search-for-symbol cl-defmethod "Could not find the definition for %s in its file" edebug-eval-top-level-form edebug-form-data-symbol markerp marker-buffer message "%s is already instrumented." find-function-noselect t "Could not find the definition in its file"] 14 (#$ . 78027)])
#@439 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.
If the callee is a generic function, Edebug will instrument all
the methods, not just the one which is about to be called.  Return
the list of symbols which were instrumented.
(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 read edebug-instrument-function] 3 (#$ . 79152) nil])
#@216 Step into the definition of the function, macro or method 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.
(defalias 'edebug-step-in #[0 "\300 \211\205\301\302\"\210\303\304!\207" [edebug-instrument-callee mapc #[257 "\300\301\"\207" [edebug-on-entry temp] 4 "\n\n(fn FUNC)"] edebug-go-mode nil] 4 (#$ . 79889) nil])
#@300 Cause Edebug to stop when FUNCTION is called.

FUNCTION needs to be edebug-instrumented for this to work; if
FUNCTION isn't, this function has no effect.

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 (#$ . 80325) "aEdebug on entry to: \nP"])
(defalias 'edebug-cancel-edebug-on-entry 'cancel-edebug-on-entry)
(defalias 'edebug--edebug-on-entry-functions #[0 "\301C\302\303\304\305\306\307!\310\"\311\312%\"\210\211\242\207" [obarray nil mapatoms make-byte-code 257 "\301!\205\211\302N\205\300\300\242B\240\207" vconcat vector [fboundp edebug-on-entry] 4 "\n\n(fn SYMBOL)"] 8])
#@178 Cause Edebug to not stop when FUNCTION is called.
The removes the effect of `edebug-on-entry'.  If FUNCTION is is
nil, remove `edebug-on-entry' on all functions.

(fn FUNCTION)
(defalias 'cancel-edebug-on-entry #[257 "\211\204\300\301!\210\211\203\211C\202\302 \211\205&\211@\303\304\305#\210A\266\202\202\207" [message "Removing `edebug-on-entry' from all functions." edebug--edebug-on-entry-functions put edebug-on-entry nil] 7 (#$ . 81119) (byte-code "\300\301\302 \211\204\f\303\304!\210\211\262\"\211\205\211\305\232?\205\306!\262C\207" [completing-read "Cancel edebug on entry to (default all functions): " edebug--edebug-on-entry-functions user-error "No functions have `edebug-on-entry'" "" intern] 5)])
#@122 Set mode to Go-nonstop, and exit to top-level.
This is useful for exiting even if `unwind-protect' code may be executed.
(defalias 'edebug-top-level-nonstop #[0 "\301\302 \207" [edebug-execution-mode Go-nonstop top-level] 1 (#$ . 81857) nil])
#@59 Association list between commands and the modes they set.
(defconst edebug-initial-mode-alist '((edebug-step-mode . step) (edebug-next-mode . next) (edebug-trace-mode . trace) (edebug-Trace-fast-mode . Trace-fast) (edebug-go-mode . go) (edebug-continue-mode . continue) (edebug-Continue-fast-mode . Continue-fast) (edebug-Go-nonstop-mode . Go-nonstop)) (#$ . 82107))
#@128 Set the initial execution mode of Edebug.
The mode is requested via the key that would be used to set the mode in
edebug-mode.
(defalias 'edebug-set-initial-mode #[0 "\303\304\305\306\307	\"@\n\310#\311H#!\312\n\"	\236A\211\203'\211\313\314\"\202*\315\316!\207" [edebug-initial-mode edebug-initial-mode-alist edebug-mode-map read-key-sequence format "Change initial edebug mode from %s (%c) to (enter key): " where-is-internal rassq firstonly 0 lookup-key message "Edebug's initial mode is now: %s" error "Key must map to one of the mode changing commands"] 9 (#$ . 82481) 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\nBBBB\312BB\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) (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-d-c-i-n-s-w (default-value 'cursor-in-non-selected-windows)) (setq-default cursor-in-non-selected-windows t))] 12 (#$ . 83076)]))
(put 'edebug-outside-excursion 'edebug-form-spec t)
#@13 

(fn EXPR)
(defalias 'edebug-eval #[257 "\300\301\302#\207" [backtrace-eval 0 edebug-after] 5 (#$ . 84078)])
#@13 

(fn EXPR)
(defalias 'edebug-safe-eval #[257 "\3001	\301!0\207\302\303@\304NA@#\207" [(error) edebug-eval edebug-format "%s: %s" error-message] 6 (#$ . 84195)])
#@14 

(fn VALUE)
(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 (#$ . 84367)])
#@14 

(fn VALUE)
(defalias 'edebug-safe-prin1-to-string #[257 "\306\206	\n\206\f\206
\307	\n\310!-\207" [edebug-print-length print-length edebug-print-level print-level edebug-print-circle print-circle t nil edebug-prin1-to-string print-readably print-escape-newlines] 6 (#$ . 84635)])
#@23 

(fn PREVIOUS-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 (#$ . 84937)])
#@28 Print the previous result.
(defalias 'edebug-previous-result #[0 "\301\302\"\207" [edebug-previous-result message "%s"] 3 (#$ . 85207) nil])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\207" [defalias edebug-prin1-to-string cl-prin1-to-string edebug-format format-message 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\312\313
\"\210\314\216rq\210b\210\315\316 !\2033\316 \317\223\210\320!B\321@!\322@!P+!\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-d-c-i-n-s-w princ edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows #[0 "\203\303	!\210\304\305!\306\305\307\"\207" [edebug-save-windows edebug-inside-windows edebug-outside-d-c-i-n-s-w edebug-set-windows default-value cursor-in-non-selected-windows set-default t] 3] marker-buffer edebug-mark-marker nil edebug-eval edebug-safe-prin1-to-string eval-expression-print-format edebug-outside-buffer edebug-outside-point edebug-outside-mark values] 5 (#$ . 85532) (byte-code "\300\301!C\207" [read--expression "Eval: "] 2)])
#@291 Evaluate sexp before point in the outside environment.
Print value in minibuffer.

If NO-TRUNCATE is non-nil (or interactively with a prefix
argument of zero), show the full length of the expression, not
limited by `edebug-print-length' or `edebug-print-level'.

(fn &optional NO-TRUNCATE)
(defalias 'edebug-eval-last-sexp #[256 "\211\203\302\211\303\304 !*\207\303\304 !\207" [edebug-print-level edebug-print-length nil edebug-eval-expression edebug-last-sexp] 3 (#$ . 86568) (byte-code "\205	\301!\302UC\207" [current-prefix-arg prefix-numeric-value 0] 2)])
#@317 Evaluate sexp before point in outside environment; insert value.
This prints the value into current buffer.

If NO-TRUNCATE is non-nil (or interactively with a prefix
argument of zero), show the full length of the expression, not
limited by `edebug-print-length' or `edebug-print-level'.

(fn &optional NO-TRUNCATE)
(defalias 'edebug-eval-print-last-sexp #[256 "\306 \212\203\307!\310\n!\210q\210\311\f!\210\312\313
\"\210\314\216rq\210b\210\315\316 !\2034\316 \317\223\210\203G\317\211\320\321!!*\202L\320\321!!+p\322\323!\210\322!\210\322\323!)\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-d-c-i-n-s-w edebug-last-sexp edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows #[0 "\203\303	!\210\304\305!\306\305\307\"\207" [edebug-save-windows edebug-inside-windows edebug-outside-d-c-i-n-s-w edebug-set-windows default-value cursor-in-non-selected-windows set-default t] 3] marker-buffer edebug-mark-marker nil edebug-safe-prin1-to-string edebug-safe-eval princ "\n" edebug-outside-buffer edebug-outside-point edebug-outside-mark edebug-print-level edebug-print-length standard-output] 5 (#$ . 87142) (byte-code "\205	\301!\302UC\207" [current-prefix-arg prefix-numeric-value 0] 2)])
(byte-code "\300\301\302\303#\210\304\211\203(\211@\301N\203!\302N\204!\305\302\301N#\210A\266\202\202\210\306\301\302\307#\207" [defvaralias gud-inhibit-global-bindings edebug-inhibit-emacs-lisp-mode-bindings nil (saved-value saved-variable-comment) put make-obsolete-variable "24.3"] 7)
#@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 (#$ . 88792))
(byte-code "\204\"\302	\303\304#\210\302	\305\306#\210\302	\307\310#\210\302	\311\312#\210\302	\313\314#\210\302\207" [edebug-inhibit-emacs-lisp-mode-bindings emacs-lisp-mode-map define-key "" edebug-step-mode "" edebug-next-mode "" edebug-go-mode "\f" edebug-where "
" edebug-set-initial-mode] 4)
(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\376#\210\302\377\201@#\210\302\201A\376#\210\302\201B\201C#\210\302\201D\201E#\210\302\201F\201G#\210\302\201H\201I#\210\302\201J\201K#\210\302\201L\304#\210\302\201M\306#\210\302\201N\310#\210\302\201O\346#\210\302\201P\350#\210\302\201Q\201R#\210\302\201S\374#\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 "U" edebug-unset-breakpoints "B" edebug-next-breakpoint "x" edebug-set-conditional-breakpoint "X" edebug-set-global-break-condition "D" edebug-toggle-disable-breakpoint "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-pop-to-backtrace "-" negative-argument "=" edebug-temp-display-freq-count "" "" "" " " "" "" #[0 "\300\301!\207" [edebug-set-breakpoint t] 2 nil nil] "\f"] 5))
#@67 Prefix key for global edebug commands, available from any buffer.
(defvar global-edebug-prefix "X" (#$ . 91285))
#@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\301\344\345#\210\301\346\347#\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 "U" edebug-unset-breakpoints "x" edebug-set-conditional-breakpoint "X" edebug-set-global-break-condition "D" edebug-toggle-disable-breakpoint "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) (#$ . 91405))
(byte-code "\203
\302!\210\303	\"\210\302\207" [global-edebug-prefix global-edebug-map global-unset-key global-set-key] 3)
#@25 Describe `edebug-mode'.
(defalias 'edebug-help #[0 "\300\301!\207" [describe-function edebug-mode] 2 (#$ . 92553) nil])
(defvar edebug--mode-saved-vars nil)
#@91 Non-nil if Edebug mode is enabled.
Use the command `edebug-mode' to change this variable.
(defvar edebug-mode nil (#$ . 92716))
(make-variable-buffer-local 'edebug-mode)
#@1178 Mode for Emacs Lisp buffers while in Edebug.

If called interactively, enable Edebug mode if ARG is positive, and
disable it if ARG is zero or negative.  If called from Lisp, also
enable the mode if ARG is omitted or nil, and toggle it if ARG is
`toggle'; disable the mode otherwise.

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 &optional ARG)
(defalias 'edebug-mode #[256 "\302 \303=\203
?\202\304!\305V\211\204?	\2036	\211A\242\211:\203.\211@AL\210\2022\306!\210\210\202\307\310\311\312#\210\202s\313\211\203k\211@\211@A\211\314!\203Y\211JB\202Z\211	B\315!L\266A\266\202\202@\210\316\310\311\312\211$\210\317\320\203}\321\202~\322\"\210\323\324!\203\242\302 \203\222\211\302 \232\203\242\325\326\327\203\235\330\202\236\331#\266\210\332 \210\207" [edebug-mode edebug--mode-saved-vars current-message toggle prefix-numeric-value 0 kill-local-variable remove-hook kill-buffer-hook edebug-kill-buffer t ((buffer-read-only . t)) local-variable-p make-local-variable add-hook run-hooks edebug-mode-hook edebug-mode-on-hook edebug-mode-off-hook called-interactively-p any " in current buffer" message "Edebug mode %sabled%s" "en" "dis" force-mode-line-update] 11 (#$ . 92894) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(defvar edebug-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\305\306\307\310\211%\207" [edebug-mode-map edebug-mode-hook variable-documentation put "Hook run after entering or leaving `edebug-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" add-minor-mode edebug-mode " *Debugging*" nil] 6)
#@79 Used on `kill-buffer-hook' when Edebug is operating in a buffer of Lisp code.
(defalias 'edebug-kill-buffer #[0 "\300\301\302\303#\207" [run-with-timer 0 nil top-level] 4 (#$ . 95407)])
#@53 Return a list of evaluations of `edebug-eval-list'.
(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 (#$ . 95599)])
#@25 

(fn EVAL-RESULT-LIST)
(defalias 'edebug-eval-display-list #[257 "\303\304\305\306 \307Z\310\"\"q\210\311 \210\n\211\2038\211@\312!\210\313 \210\312\211A\262\242!\210\313 \210\314!\210A\266\202\202\210\315!)\207" [edebug-eval-buffer standard-output edebug-eval-list format ";%s\n" make-string window-width 2 45 erase-buffer prin1 terpri princ edebug-pop-to-buffer] 8 (#$ . 95836)])
(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])
#@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 (#$ . 96414)])
#@102 Redisplay eval list in outside environment.
May only be called from within `edebug--recursive-edit'.
(defalias 'edebug-eval-redisplay #[0 "\306 \210\212\203\307!\310\n!\210q\210\311\f!\210\312\313
\"\210\314\216rq\210b\210\315\316 !\2035\316 \317\223\210\320\321 !+\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-d-c-i-n-s-w edebug-create-eval-buffer edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows #[0 "\203\303	!\210\304\305!\306\305\307\"\207" [edebug-save-windows edebug-inside-windows edebug-outside-d-c-i-n-s-w edebug-set-windows default-value cursor-in-non-selected-windows set-default t] 3] marker-buffer edebug-mark-marker nil edebug-eval-display-list edebug-eval-result-list edebug-outside-buffer edebug-outside-point edebug-outside-mark] 3 (#$ . 96697)])
#@50 Switch to the evaluation list buffer "*edebug*".
(defalias 'edebug-visit-eval-list #[0 "\301 \210\302!\207" [edebug-eval-buffer edebug-eval-redisplay edebug-pop-to-buffer] 2 (#$ . 97617) nil])
#@68 Replace the evaluation list with the sexps now in the eval buffer.
(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 \210b\207" [edebug-eval-list nil edebug-skip-whitespace forward-sexp 1 edebug-last-sexp re-search-forward "^;" t " 	\n
" 59 edebug-eval-redisplay] 6 (#$ . 97817) nil])
#@44 Delete the item under point and redisplay.
(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 (#$ . 98260) 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) (#$ . 98549))
(put 'edebug-eval-mode 'mode-class 'special)
(defvar edebug-eval-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [edebug-eval-mode-hook variable-documentation put "Hook run after 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 edebug-eval-mode] 4)
(defvar edebug-eval-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [edebug-eval-mode-abbrev-table edebug-eval-mode-map variable-documentation put purecopy "Keymap for `edebug-eval-mode'." boundp edebug-eval-mode-syntax-table definition-name edebug-eval-mode (lambda (#1=#:def-tmp-var) (defvar edebug-eval-mode-syntax-table #1#)) make-syntax-table "Syntax table for `edebug-eval-mode'." (lambda (#1#) (defvar edebug-eval-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `edebug-eval-mode'." derived-mode-parent lisp-interaction-mode] 5)
#@622 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 or penultimate step
during initialization.
(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 (#$ . 100278) 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 (#$ . 101671)])
#@129 Stack frames of the current Edebug Backtrace buffer without instrumentation.
This should be a list of `edebug---frame' objects.
(defvar edebug-backtrace-frames nil (#$ . 102194))
(make-variable-buffer-local 'edebug-backtrace-frames)
#@126 Stack frames of the current Edebug Backtrace buffer with instrumentation.
This should be a list of `edebug---frame' objects.
(defvar edebug-instrumented-backtrace-frames nil (#$ . 102434))
(make-variable-buffer-local 'edebug-instrumented-backtrace-frames)
#@72 compiler-macro for inlining `edebug--frame-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-p (and (memq (type-of cl-x) cl-struct-edebug--frame-tags) t)) nil] 9 (#$ . 102696)])
(put 'edebug--frame-p 'compiler-macro 'edebug--frame-p--cmacro)
#@13 

(fn CL-X)
(defalias 'edebug--frame-p #[257 "\301!>\205	\302\207" [cl-struct-edebug--frame-tags type-of t] 3 (#$ . 103050)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put edebug--frame-p side-effect-free error-free put edebug--frame cl-deftype-satisfies] 5)
#@76 compiler-macro for inlining `edebug--frame-evald'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-evald--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-evald (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 1))) nil] 9 (#$ . 103338)])
(put 'edebug--frame-evald 'compiler-macro 'edebug--frame-evald--cmacro)
#@64 Access slot "evald" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-evald #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 1] 5 (#$ . 103760)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-evald side-effect-free t] 4)
#@74 compiler-macro for inlining `edebug--frame-fun'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-fun--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-fun (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 2))) nil] 9 (#$ . 104112)])
(put 'edebug--frame-fun 'compiler-macro 'edebug--frame-fun--cmacro)
#@62 Access slot "fun" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-fun #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 2] 5 (#$ . 104524)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-fun side-effect-free t] 4)
#@75 compiler-macro for inlining `edebug--frame-args'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-args--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-args (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 3))) nil] 9 (#$ . 104870)])
(put 'edebug--frame-args 'compiler-macro 'edebug--frame-args--cmacro)
#@63 Access slot "args" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-args #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 3] 5 (#$ . 105287)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-args side-effect-free t] 4)
#@76 compiler-macro for inlining `edebug--frame-flags'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-flags--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-flags (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 4))) nil] 9 (#$ . 105636)])
(put 'edebug--frame-flags 'compiler-macro 'edebug--frame-flags--cmacro)
#@64 Access slot "flags" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-flags #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 4] 5 (#$ . 106058)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-flags side-effect-free t] 4)
#@77 compiler-macro for inlining `edebug--frame-locals'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-locals--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-locals (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 5))) nil] 9 (#$ . 106410)])
(put 'edebug--frame-locals 'compiler-macro 'edebug--frame-locals--cmacro)
#@65 Access slot "locals" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-locals #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 5] 5 (#$ . 106837)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-locals side-effect-free t] 4)
#@77 compiler-macro for inlining `edebug--frame-buffer'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-buffer--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-buffer (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 6))) nil] 9 (#$ . 107192)])
(put 'edebug--frame-buffer 'compiler-macro 'edebug--frame-buffer--cmacro)
#@65 Access slot "buffer" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-buffer #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 6] 5 (#$ . 107619)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-buffer side-effect-free t] 4)
#@74 compiler-macro for inlining `edebug--frame-pos'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-pos--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-pos (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 7))) nil] 9 (#$ . 107974)])
(put 'edebug--frame-pos 'compiler-macro 'edebug--frame-pos--cmacro)
#@62 Access slot "pos" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-pos #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 7] 5 (#$ . 108386)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-pos side-effect-free t] 4)
#@79 compiler-macro for inlining `edebug--frame-def-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-def-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-def-name (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 8))) nil] 9 (#$ . 108732)])
(put 'edebug--frame-def-name 'compiler-macro 'edebug--frame-def-name--cmacro)
#@67 Access slot "def-name" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-def-name #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 8] 5 (#$ . 109169)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-def-name side-effect-free t] 4)
#@83 compiler-macro for inlining `edebug--frame-before-index'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-before-index--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-before-index (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 9))) nil] 9 (#$ . 109530)])
(put 'edebug--frame-before-index 'compiler-macro 'edebug--frame-before-index--cmacro)
#@71 Access slot "before-index" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-before-index #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 9] 5 (#$ . 109987)])
(byte-code "\300\301\302\303#\300\207" [function-put edebug--frame-before-index side-effect-free t] 4)
#@82 compiler-macro for inlining `edebug--frame-after-index'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'edebug--frame-after-index--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--frame-after-index (progn (or (edebug--frame-p cl-x) (signal 'wrong-type-argument (list 'edebug--frame cl-x))) (aref cl-x 10))) nil] 9 (#$ . 110360)])
(put 'edebug--frame-after-index 'compiler-macro 'edebug--frame-after-index--cmacro)
#@70 Access slot "after-index" of `edebug--frame' struct CL-X.

(fn CL-X)
(defalias 'edebug--frame-after-index #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 10] 5 (#$ . 110813)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put edebug--frame-after-index side-effect-free t defalias copy-edebug--frame copy-sequence] 4)
#@154 compiler-macro for inlining `edebug--make-frame'.

(fn CL-WHOLE &cl-quote &key EVALD FUN ARGS FLAGS LOCALS BUFFER POS DEF-NAME BEFORE-INDEX AFTER-INDEX)
(defalias 'edebug--make-frame--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262\202C\314\f>A@\203e\315\262\202C\316\317@\"\210\202C\210\320\321\322\315\315&\207" [plist-member :evald :fun :args :flags :locals :buffer :pos :def-name :before-index :after-index (:evald :fun :args :flags :locals :buffer :pos :def-name :before-index :after-index :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:evald :fun :args :flags :locals :buffer :pos :def-name :before-index :after-index)" cl--defsubst-expand (evald fun args flags locals buffer pos def-name before-index after-index) (cl-block edebug--make-frame (record 'edebug--frame evald fun args flags locals buffer pos def-name before-index after-index))] 28 (#$ . 111237)])
(put 'edebug--make-frame 'compiler-macro 'edebug--make-frame--cmacro)
#@134 Constructor for objects of type `edebug--frame'.

(fn &key EVALD FUN ARGS FLAGS LOCALS BUFFER POS DEF-NAME BEFORE-INDEX AFTER-INDEX)
(defalias 'edebug--make-frame #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262\202C\314\f>A@\203e\315\262\202C\316\317@\"\210\202C\210\320\321&\207" [plist-member :evald :fun :args :flags :locals :buffer :pos :def-name :before-index :after-index (:evald :fun :args :flags :locals :buffer :pos :def-name :before-index :after-index :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:evald :fun :args :flags :locals :buffer :pos :def-name :before-index :after-index)" record edebug--frame] 23 (#$ . 112389)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put edebug--make-frame side-effect-free t cl-struct-define edebug--frame nil backtrace-frame record ((cl-tag-slot) (evald nil) (fun nil) (args nil) (flags nil) (locals nil) (buffer nil) (pos nil) (def-name) (before-index) (after-index)) cl-struct-edebug--frame-tags] 11)
#@61 Display the current backtrace in a `backtrace-mode' window.
(defalias 'edebug-pop-to-backtrace #[0 "\203\n\304!\204\305\306!\307!\210\310\311!\204 \311 \210\312\313\314\"\210\315\316\317\320#\321	!\211\322 \210eb\207" [edebug-backtrace-buffer edebug-instrumented-backtrace-frames edebug-backtrace-frames backtrace-frames buffer-name generate-new-buffer "*Edebug Backtrace*" pop-to-buffer derived-mode-p backtrace-mode add-hook backtrace-goto-source-functions edebug--backtrace-goto-source backtrace-get-frames edebug-debugger :constructor edebug--make-frame edebug--strip-instrumentation backtrace-print] 5 (#$ . 113585) nil])
#@343 Return a new list of backtrace frames with instrumentation removed.
Remove frames for Edebug's functions and the lambdas in
`edebug-enter' wrappers.  Fill in the def-name, before-index
and after-index fields in both FRAMES and the returned list
of deinstrumented frames, for those frames where the source
code location is known.

(fn FRAMES)
(defalias 'edebug--strip-instrumentation #[257 "\301\211\211\211\211G\302!\211\203\325\211@\303!\304!>\204#\305\306\307D\"\210\310H\304!>\2045\305\306\307D\"\210\311HS\262\312\267\202e\313\262\211@\262\n\202\314\211@:\203Y\211@A@\202[\211@\262	\211A@\262\202\314\314!\203\222\315!\210\316$\210\316$\210B\262\301\262	\301\262\202\314:\203\314@\211\317>\203\313\204\302\315!\210\316\f\f\f$\210\316\f\f\f$\210B\262\301\262\n\301\262	\301\262\f\210\266A\266\202\202\210\207" [cl-struct-edebug--frame-tags nil reverse copy-edebug--frame type-of signal wrong-type-argument edebug--frame 2 3 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (edebug-enter 66 edebug-after 76)) t edebug--symbol-not-prefixed-p edebug--unwrap-frame edebug--add-source-info (closure lambda)] 18 (#$ . 114230)])
#@72 Return non-nil if SYM is a symbol not prefixed by "edebug-".

(fn SYM)
(defalias 'edebug--symbol-not-prefixed-p #[257 "\2119\205\f\300\301\302!\"?\207" [string-prefix-p "edebug-" symbol-name] 5 (#$ . 115470)])
#@115 Remove Edebug's instrumentation from FRAME.
Strip it from the function and any unevaluated arguments.

(fn FRAME)
(defalias 'edebug--unwrap-frame #[257 "\301!>\204\302\303\304D\"\210\211\211\305\306\301!>\204#\302\303\304D\"\210\305H!I\266\301!>\2049\302\303\304D\"\210\211\307H?\205\201\310\301!>\204P\302\303\304D\"\210\311H\211\203g\211@\306!B\262A\266\202\202S\210\301!>\204w\302\303\304D\"\210\211\311\237I\262\262\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 2 edebug-unwrap* 1 nil 3] 9 (#$ . 115689)])
#@167 Update FRAME with the additional info needed by an edebug--frame.
Save DEF-NAME, BEFORE-INDEX and AFTER-INDEX in FRAME.

(fn FRAME DEF-NAME BEFORE-INDEX AFTER-INDEX)
(defalias 'edebug--add-source-info #[1028 "\2039\2039\301!>\204\302\303\304D\"\210\211\305\306\307\301	!>\204.\302\303\304D\"\210\305H!\310\311#I\266\301!>\204I\302\303\304D\"\210\211\312\205QI\266\301!>\204d\302\303\304D\"\210\211\313I\266\301!>\204{\302\303\304D\"\210\211\314I\207" [cl-struct-edebug--frame-tags type-of signal wrong-type-argument edebug--frame 4 plist-put copy-sequence :source-available t 8 9 10] 13 (#$ . 116280)])
(defalias 'edebug--backtrace-goto-source #[0 "\302\303\206`\304\"\262\2118\305!	>\204\306\307\310D\"\210\211\311H\205_\305!	>\2042\306\307\310D\"\210\211\311H\312N\211@\3138\314\315!!\210\316!\305!	>\204W\306\307\310D\"\210\317HH\\b\266\203\207" [backtrace-frames cl-struct-edebug--frame-tags nil get-text-property backtrace-index type-of signal wrong-type-argument edebug--frame 8 edebug 2 pop-to-buffer marker-buffer marker-position 9] 11])
#@62 Show Edebug's instrumentation in an Edebug Backtrace buffer.
(defalias 'edebug-backtrace-show-instrumentation #[0 "	=?\205	\302 \207" [backtrace-frames edebug-instrumented-backtrace-frames revert-buffer] 2 (#$ . 117399) nil])
#@62 Hide Edebug's instrumentation in an Edebug Backtrace buffer.
(defalias 'edebug-backtrace-hide-instrumentation #[0 "	=?\205	\302 \207" [backtrace-frames edebug-backtrace-frames revert-buffer] 2 (#$ . 117635) 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 \262db\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 (#$ . 117859)])
#@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 (#$ . 118470)])
#@728 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.
(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 (edebug-unknown edebug-ok-coverage) "=" "" int-to-string " " "\n"] 20 (#$ . 118686) nil])
#@111 Temporarily display the frequency count data for the current definition.
It is removed when you hit any char.
(defalias 'edebug-temp-display-freq-count #[0 "\302\303 \210\304 \210\305	\306 C\"\307 )\207" [inhibit-read-only unread-command-events t undo-boundary edebug-display-freq-count append read-event undo] 3 (#$ . 120112) nil])
#@17 

(fn VARIABLE)
(defalias 'edebug-toggle #[257 "\211J?L\210\300\301\211J#\207" [message "%s: %s"] 5 (#$ . 120453)])
(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] ["Unset Breakpoints In Form" edebug-unset-breakpoints t] ["Toggle Disable Breakpoint" edebug-toggle-disable-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-pop-to-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])) (#$ . 120597))
(defalias 'edebug-window-live-p 'window-live-p)
(defalias 'edebug-mark #[0 "\300\301!\207" [mark t] 2])
#@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 (#$ . 122754) (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\262D\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 (#$ . 123470))
(easy-menu-do-define 'edebug-menu edebug-mode-map "Edebug menus" edebug-mode-menus)
(defalias 'edebug--require-cl-read #[0 "\300\301!\207" [require edebug-cl-read] 2])
(byte-code "\300\301!\203\302\303\304\"\210\202\302\305\304\"\210\302\306\307\"\207" [featurep cl-read add-hook edebug-setup-hook edebug--require-cl-read cl-read-load-hooks called-interactively-p-functions edebug--called-interactively-skip] 3)
#@24 

(fn I FRAME1 FRAME2)
(defalias 'edebug--called-interactively-skip #[771 "A@\242\300=\205)A@A@\301=\205)\211A@\302=\205)\303\304\"A@\302=\203(\305\207\306\207" [lambda nil edebug-enter backtrace-frame called-interactively-p 2 1] 6 (#$ . 123944)])
(edebug-install-read-eval-functions)
#@42 Unload the Edebug source level debugger.
(defalias 'edebug-unload-function #[0 "\203\f\301\302\216\303 \210)\304\305\306\"\210\304\307\310\"\210\311 \210\301\207" [edebug-active nil #[0 "\300\301\302\303#\207" [run-with-idle-timer 0 nil #[0 "\300\301!\207" [unload-feature edebug] 2]] 4] abort-recursive-edit remove-hook called-interactively-p-functions edebug--called-interactively-skip cl-read-load-hooks edebug--require-cl-read edebug-uninstall-read-eval-functions] 3 (#$ . 124242)])
#@15 

(fn SYMBOL)
(defalias 'edebug--unwrap*-symbol-function #[257 "\211K\300:\203$@\211\301=\203A\302\"\262\202\303\"\262\202(\211\303\"\207" [#[514 "\300!\301!\211\232\203\302\202\203\303B\202\211\207" [advice--cd*r edebug-unwrap* nil macro] 6 "\n\n(fn WAS-MACRO F)"] macro t nil] 8 (#$ . 124738)])
#@176 Remove Edebug instrumentation from FUNCTIONS.
Interactively, the user is prompted for the function to remove
instrumentation for, defaulting to all functions.

(fn FUNCTIONS)
(defalias 'edebug-remove-instrumentation #[257 "\211\211\203\211@\300!\211\203\301\"\210\210A\266\202\202\210\302\303\304\305\306#\"\207" [edebug--unwrap*-symbol-function defalias message "Removed edebug instrumentation from %s" mapconcat symbol-name ", "] 7 (#$ . 125071) (byte-code "\301C\302\303\304\305\306\307!\310\"\311\312%\"\210\211\242\204\313\314!\210\315\316\242\"\211\2032\211\317\232\2042\320!C\2024\242\262\262C\207" [obarray nil mapatoms make-byte-code 257 "\211\301N\205\302!\204\303!\205\304!\205\300\300\242B\240\207" vconcat vector [edebug functionp macrop edebug--unwrap*-symbol-function] 4 "\n\n(fn SYMBOL)" user-error "Found no functions to remove instrumentation from" completing-read "Remove instrumentation from (default all functions): " "" intern] 8)])
(provide 'edebug)
Zerion Mini Shell 1.0