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



(byte-code "\300\301!\210\300\302!\210\303\304\305\306\307\310\307\311\312\313\314\315\314\316&
\210\317\320\321\322\323DD\324\325\326%\210\317\327\321\322\330DD\331\325\332%\210\317\333\321\322\334DD\335\325\336%\210\317\337\321\322\340DD\341\325\336%\210\317\342\321\322\343DD\344\325\345%\210\317\346\321\322\347DD\350\325\336%\210\317\351\321\322\352DD\353\325\354%\207" [require replace cl-lib custom-declare-group kmacro nil "Simplified keyboard macro user interface." :group keyboard convenience :version "22.1" :link (emacs-commentary-link :tag "Commentary" "kmacro.el") (emacs-library-link :tag "Lisp File" "kmacro.el") custom-declare-variable kmacro-call-mouse-event funcall function #[0 "\300\207" [S-mouse-3] 1 #1=""] "The mouse event used by kmacro to call a macro.\nSet to nil if no mouse binding is desired." :type symbol kmacro-ring-max #[0 "\300\207" [8] 1 #1#] "Maximum number of keyboard macros to save in macro ring." integer kmacro-execute-before-append #[0 "\300\207" [t] 1 #1#] "Controls whether appending to a macro starts by executing the macro.\nIf non-nil, using a single \\[universal-argument] prefix executes the macro\nbefore appending, while more than one \\[universal-argument] prefix does not\nexecute the macro.\nOtherwise, a single \\[universal-argument] prefix does not execute the\nmacro, while more than one \\[universal-argument] prefix causes the\nmacro to be executed before appending to it." boolean kmacro-repeat-no-prefix #[0 "\300\207" [t] 1 #1#] "Allow repeating certain macro commands without entering the \\[kmacro-keymap] prefix." kmacro-call-repeat-key #[0 "\300\207" [t] 1 #1#] "Allow repeating macro call using last key or a specific key." (choice (const :tag "Disabled" nil) (const :tag "Last key" t) (character :tag "Character" :value 101) (symbol :tag "Key symbol" :value RET)) kmacro-call-repeat-with-arg #[0 "\300\207" [nil] 1 #1#] "Repeat macro call with original arg when non-nil; repeat once if nil." kmacro-step-edit-mini-window-height #[0 "\300\207" [0.75] 1 #1#] "Override `max-mini-window-height' when step edit keyboard macro." number] 14)
#@37 Keymap for keyboard macro commands.
(defvar kmacro-keymap (byte-code "\300 \301
\302\303#\210\301
\304\303#\210\301
\305\306#\210\301
\307\310#\210\301
\311\312#\210\301
\313\314#\210\301
\315\316#\210\301
\317\320#\210\301
\321\322#\210\301
\323\324#\210\301
\325\326#\210\301
\327\330#\210\301
\331\332#\210\301
\333\334#\210\301
\335\336#\210\301
\337\340#\210\301
\341\342#\210\301
\343\344#\210\301
\345\346#\210\301
\347\350#\210\301
\351\352#\210\301
\353\354#\210\301
\355\356#\210\301
\357\360#\210\207" [make-sparse-keymap define-key "s" kmacro-start-macro "" "" kmacro-end-or-call-macro-repeat "r" apply-macro-to-region-lines "q" kbd-macro-query "d" kmacro-redisplay "" kmacro-cycle-ring-next "" kmacro-cycle-ring-previous "" kmacro-view-macro-repeat "" kmacro-delete-ring-head "" kmacro-swap-ring "\f" kmacro-call-ring-2nd-repeat "" kmacro-set-format "" kmacro-set-counter "	" kmacro-insert-counter "
" kmacro-add-counter "" kmacro-edit-macro-repeat "
" kmacro-edit-macro "e" edit-kbd-macro "l" kmacro-edit-lossage " " kmacro-step-edit-macro "b" kmacro-bind-to-key "n" kmacro-name-last-macro "x" kmacro-to-register] 5) (#$ . 2189))
(byte-code "\302\300\"\210	\203\303\304	!\305\"\210\302\207" [kmacro-keymap kmacro-call-mouse-event defalias global-set-key vector kmacro-end-call-mouse] 3)
(defalias 'kmacro-keyboard-quit #[0 "?\206\301=\206\302 \206\303 \207" [defining-kbd-macro append kmacro-ring-empty-p kmacro-pop-ring] 2])
#@238 Current keyboard macro counter.

This is normally initialized to zero when the macro is defined,
and incremented each time the value of the counter is inserted
into a buffer.  See `kmacro-start-macro-or-insert-counter' for
more details.
(defvar kmacro-counter 0 (#$ . 3657))
(defvar kmacro-default-counter-format "%d")
#@97 Current keyboard macro counter format.

Can be set directly via `kmacro-set-format', which see.
(defvar kmacro-counter-format "%d" (#$ . 3982))
#@43 Macro format at start of macro execution.
(defvar kmacro-counter-format-start kmacro-counter-format (#$ . 4132))
#@44 Macro counter at start of macro execution.
(defvar kmacro-counter-value-start kmacro-counter (#$ . 4251))
#@37 Last counter inserted by key macro.
(defvar kmacro-last-counter 0 (#$ . 4363))
#@66 Initial counter value for the next keyboard macro to be defined.
(defvar kmacro-initial-counter-value nil (#$ . 4448))
#@379 Insert current value of `kmacro-counter', then increment it by ARG.
Interactively, ARG defaults to 1.  With \[universal-argument], insert
the previous value of `kmacro-counter', and do not increment the
current value.

The previous value of the counter is the one it had before
the last increment.

See Info node `(emacs) Keyboard Macro Counter' for more
information.

(fn ARG)
(defalias 'kmacro-insert-counter #[257 "\203\304\211:\203\305\n\"c\207\305\n	\"c\210\306\307!!\207" [kmacro-initial-counter-value kmacro-counter kmacro-counter-format kmacro-last-counter nil format kmacro-add-counter prefix-numeric-value] 4 (#$ . 4574) "P"])
#@672 Set the format of `kmacro-counter' to FORMAT.

The default format is "%d", which means to insert the number in
decimal without any padding.  You can specify any format string
that the `format' function accepts and that makes sense with a
single integer extra argument.

If you run this command while no keyboard macro is being defined,
the new format affects all subsequent macro definitions.

If you run this command while defining a keyboard macro, it
affects only that macro, from that point on.

Do not put the format string inside double quotes when you insert
it in the minibuffer.

See Info node `(emacs) Keyboard Macro Counter' for more
information.

(fn FORMAT)
(defalias 'kmacro-set-format #[257 "\211\304\232\203\n\305\202\211	\206\n?\205\211\207" [kmacro-counter-format defining-kbd-macro executing-kbd-macro kmacro-default-counter-format "" "%d"] 3 (#$ . 5228) "sMacro Counter Format: "])
#@124 Display current counter value.

See Info node `(emacs) Keyboard Macro Counter' for more
information.

(fn &optional VALUE)
(defalias 'kmacro-display-counter #[256 "\211\204\262
\302\303\304	\"#\207" [kmacro-counter kmacro-counter-format message "New macro counter value: %s (%d)" format] 6 (#$ . 6147)])
#@259 Set the value of `kmacro-counter' to ARG, or prompt for value if no argument.
With \[universal-argument] prefix, reset counter to its value prior to this iteration of the
macro.

See Info node `(emacs) Keyboard Macro Counter' for more
information.

(fn ARG)
(defalias 'kmacro-set-counter #[257 "\204	\204\306
\211!\207
\203
<\203\202\211	?\205'\306 \207" [defining-kbd-macro executing-kbd-macro kmacro-initial-counter-value kmacro-counter kmacro-last-counter current-prefix-arg kmacro-display-counter kmacro-counter-value-start] 4 (#$ . 6463) "NMacro counter value: "])
#@218 Add the value of numeric prefix arg (prompt if missing) to `kmacro-counter'.
With \[universal-argument], restore previous counter value.

See Info node `(emacs) Keyboard Macro Counter' for more
information.

(fn ARG)
(defalias 'kmacro-add-counter #[257 "\203\305\n	\203<\203\211\202	\210	\\\210\f?\205&\306 \207" [kmacro-initial-counter-value kmacro-counter kmacro-last-counter current-prefix-arg executing-kbd-macro nil kmacro-display-counter] 4 (#$ . 7058) "NAdd to macro counter: "])
#@51 Function called prior to each iteration of macro.
(defalias 'kmacro-loop-setup-function #[0 "\n\304\207" [kmacro-counter-format-start kmacro-counter-format kmacro-counter kmacro-counter-value-start t] 1 (#$ . 7569)])
#@273 The keyboard macro ring.
Each element is a list (MACRO COUNTER FORMAT).  Actually, the head of
the macro ring (when defining or executing) is not stored in the ring;
instead it is available in the variables `last-kbd-macro', `kmacro-counter',
and `kmacro-counter-format'.
(defvar kmacro-ring nil (#$ . 7796))
(defvar kmacro-view-last-item nil)
(defvar kmacro-view-item-no 0)
#@43 Return pseudo head element in macro ring.
(defalias 'kmacro-ring-head #[0 "\205	\nE\207" [last-kbd-macro kmacro-counter kmacro-counter-format-start] 3 (#$ . 8177)])
#@67 Push ELT or current macro onto `kmacro-ring'.

(fn &optional ELT)
(defalias 'kmacro-push-ring #[256 "\211\206\302 \211\262\205\303\304\305	#)\207" [history-delete-duplicates kmacro-ring-max kmacro-ring-head nil add-to-history kmacro-ring] 5 (#$ . 8352)])
#@12 

(fn ELT)
(defalias 'kmacro-split-ring-element #[257 "\211@\211A@\303
8\211\207" [last-kbd-macro kmacro-counter kmacro-counter-format-start 2] 3 (#$ . 8620)])
#@118 Pop head element off macro ring (no check).
Non-nil arg RAW means just return raw first element.

(fn &optional RAW)
(defalias 'kmacro-pop-ring1 #[256 "@
\204\301@!\210A\207" [kmacro-ring kmacro-split-ring-element] 4 (#$ . 8790)])
#@107 Pop head element off macro ring.
Non-nil arg RAW means just return raw first element.

(fn &optional RAW)
(defalias 'kmacro-pop-ring #[256 "\300 ?\205	\301
!\207" [kmacro-ring-empty-p kmacro-pop-ring1] 3 (#$ . 9034)])
#@160 Tell user and return t if `last-kbd-macro' is nil or `kmacro-ring' is empty.
Check only `last-kbd-macro' if optional arg NONE is non-nil.

(fn &optional NONE)
(defalias 'kmacro-ring-empty-p #[256 "\204	\203\302 \210\202\204\303\304!\210\305\207\211\204&	\204&\303\306!\210\305\207\307\207" [last-kbd-macro kmacro-ring kmacro-pop-ring1 message "No keyboard macro defined." t "Only one keyboard macro defined." nil] 3 (#$ . 9260)])
#@277 Display a keyboard MACRO.
Optional arg TRUNC non-nil specifies to limit width of macro to 60 chars.
Optional arg DESCR is descriptive text for macro; default is "Macro:".
Optional arg EMPTY is message to print if no macros are defined.

(fn MACRO &optional TRUNC DESCR EMPTY)
(defalias 'kmacro-display #[1025 "\203B\302!\211G\205\211\303V\304\305\206\306\307U\203\"\310\202)\311\312\311	\"\"\2035\307\313O\2027\203?\314\202@\310%\207\304\315\206I\316\"\207" [kmacro-counter kmacro-counter-format-start format-kbd-macro 60 message "%s%s: %s%s" "Macro" 0 "" format " [%s]" 59 "..." "%s" "No keyboard macros defined"] 15 (#$ . 9709)])
#@77 Process kmacro commands keys immediately after cycling the ring.

(fn KEYS)
(defalias 'kmacro-repeat-on-last-key #[257 "\305
!\262
\211GS\306\211\211\203d
\204d\307 I\203d\310\311\"\211\262\203d\312N\211\262\203d\313\311!\210\211\314\267\202_	\203F\306\306!\210)\202_\315\311\"\210\202_\306\306!\210)\202_\306!\210\311\262\306\202\266\205s\313\311!\210\fB\211\207" [last-kbd-macro kmacro-ring kmacro-repeat-no-prefix last-input-event unread-command-events vconcat nil read-event key-binding t kmacro-repeat clear-this-command-keys #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ring 56 head 78 stop 88)) kmacro-display] 8 (#$ . 10373)])
(defalias 'kmacro-get-repeat-prefix #[0 "\301\205\302 \211\262\205\211G\303V\205\211\207" [kmacro-repeat-no-prefix nil this-single-command-keys 1] 3])
#@103 Execute item ITEM from the macro ring.
ARG is the number of times to execute the item.

(fn ITEM ARG)
(defalias 'kmacro-exec-ring-item #[514 "
A@\3028\303@\304#\210
A	\240*\207" [kmacro-counter-format-start kmacro-counter 2 execute-kbd-macro kmacro-loop-setup-function] 6 (#$ . 11247)])
#@56 Execute second keyboard macro in macro ring.

(fn ARG)
(defalias 'kmacro-call-ring-2nd #[257 "\301 ?\205\302@\"\207" [kmacro-ring kmacro-ring-empty-p kmacro-exec-ring-item] 4 (#$ . 11545) "P"])
#@159 Execute second keyboard macro in macro ring.
This is like `kmacro-call-ring-2nd', but allows repeating macro commands
without repeating the prefix.

(fn ARG)
(defalias 'kmacro-call-ring-2nd-repeat #[257 "\301 \302!\210\205\211\205\303
!\207" [kmacro-ring kmacro-get-repeat-prefix kmacro-call-ring-2nd kmacro-repeat-on-last-key] 4 (#$ . 11750) "P"])
(put 'kmacro-call-ring-2nd-repeat 'kmacro-repeat 'head)
#@54 Display the second macro in the keyboard macro ring.
(defalias 'kmacro-view-ring-2nd #[0 "\301 ?\205
\302@@\303\304#\207" [kmacro-ring kmacro-ring-empty-p kmacro-display nil "2nd macro"] 4 (#$ . 12167) nil])
#@148 Move to next keyboard macro in keyboard macro ring.
Displays the selected macro in the echo area.
The ARG parameter is unused.

(fn &optional ARG)
(defalias 'kmacro-cycle-ring-next #[256 "\302 ?\205+\303 \210\304 G\211\305Z\233\211A@
\306\241\210\307
!\210\310	\311\"\210\205)\312!\266\204\207" [kmacro-ring last-kbd-macro kmacro-ring-empty-p kmacro-push-ring kmacro-get-repeat-prefix 2 nil kmacro-split-ring-element kmacro-display t kmacro-repeat-on-last-key] 8 (#$ . 12384) nil])
(put 'kmacro-cycle-ring-next 'kmacro-repeat 'ring)
#@152 Move to previous keyboard macro in keyboard macro ring.
Displays the selected macro in the echo area.
The ARG parameter is unused.

(fn &optional ARG)
(defalias 'kmacro-cycle-ring-previous #[256 "\302 ?\205*\303 \304 \305 \210\203
C\244\210\202\211C\306	\307\"\210
\205(\310!\266\202\207" [kmacro-ring last-kbd-macro kmacro-ring-empty-p kmacro-get-repeat-prefix kmacro-ring-head kmacro-pop-ring1 kmacro-display t kmacro-repeat-on-last-key] 6 (#$ . 12930) nil])
(put 'kmacro-cycle-ring-previous 'kmacro-repeat 'ring)
#@49 Swap first two elements on keyboard macro ring.
(defalias 'kmacro-swap-ring #[0 "\301 ?\205\302 \303 \210\304
!\266\305\306\"\207" [last-kbd-macro kmacro-ring-empty-p kmacro-ring-head kmacro-pop-ring1 kmacro-push-ring kmacro-display t] 3 (#$ . 13462) nil])
#@97 Delete current macro from keyboard macro ring.
The ARG parameter is unused.

(fn &optional ARG)
(defalias 'kmacro-delete-ring-head #[256 "\302\303!?\205\204\304\202\305 \210\306	\303\304\307$\207" [kmacro-ring last-kbd-macro kmacro-ring-empty-p t nil kmacro-pop-ring kmacro-display "Keyboard macro ring is now empty."] 6 (#$ . 13729) nil])
(put 'kmacro-delete-ring-head 'kmacro-repeat 'head)
#@998 Record subsequent keyboard input, defining a keyboard macro.
The commands are recorded even as they are executed.
Use \[kmacro-end-macro] to finish recording and make the macro available.
Use \[kmacro-end-and-call-macro] to execute the macro.

Non-nil arg (prefix arg) means append to last macro defined.

With \[universal-argument] prefix, append to last keyboard macro
defined.  Depending on `kmacro-execute-before-append', this may begin
by re-executing the last macro as if you typed it again.

Otherwise, it sets `kmacro-counter' to ARG or 0 if missing before
defining the macro.

Use \[kmacro-insert-counter] to insert (and increment) the macro counter.
The counter value can be set or modified via \[kmacro-set-counter] and \[kmacro-add-counter].
The format of the counter can be modified via \[kmacro-set-format].

Use \[kmacro-name-last-macro] to give it a name that will remain valid even
after another macro is defined.
Use \[kmacro-bind-to-key] to bind it to a key sequence.

(fn ARG)
(defalias 'kmacro-start-macro #[257 "\204	\203\f\306\307!\207\211\205\211<\211\204@\n\203!\310\n\fE!\210
\203+\311!\2060
\2060\312\313\314
\211\205V\203R@\315V\202V@\315U\"\210\205c\211\205c\316\211\207" [defining-kbd-macro executing-kbd-macro last-kbd-macro kmacro-counter kmacro-counter-format-start kmacro-initial-counter-value message "Already defining keyboard macro." kmacro-push-ring prefix-numeric-value 0 nil start-kbd-macro 4 append kmacro-counter-value-start kmacro-last-counter kmacro-default-counter-format kmacro-counter-format kmacro-execute-before-append] 6 (#$ . 14136) "P"])
#@413 Finish defining a keyboard macro.
The definition was started by \[kmacro-start-macro].
The macro is now available for use via \[kmacro-call-macro],
or it can be given a name with \[kmacro-name-last-macro] and then invoked
under that name.

With numeric arg, repeat macro now that many times,
counting the definition just completed as the first repetition.
An argument of zero means repeat until error.

(fn ARG)
(defalias 'kmacro-end-macro #[257 "?\205*\303
\304\"\210	\205*	G\305U\205*\306\307\310!\210	?\205*\n\205*\311 \210\202\207" [executing-kbd-macro last-kbd-macro kmacro-ring end-kbd-macro kmacro-loop-setup-function 0 nil message "Ignore empty macro" kmacro-pop-ring1] 4 (#$ . 15772) "P"])
#@591 Call the keyboard MACRO that you defined with \[kmacro-start-macro].
A prefix argument serves as a repeat count.  Zero means repeat until error.
MACRO defaults to `last-kbd-macro'.

When you call the macro, you can call the macro again by repeating
just the last key in the key sequence that you used to call this
command.  See `kmacro-call-repeat-key' and `kmacro-call-repeat-with-arg'
for details on how to adjust or disable this behavior.

To give a macro a name so you can call it even after defining others,
use \[kmacro-name-last-macro].

(fn ARG &optional NO-REPEAT END-MACRO MACRO)
(defalias 'kmacro-call-macro #[1025 "\204\f\304 G\305V\204\306=\205\203\307!\210\202*
\206#	\310\311\"\210):\2033@\262\203=\312V\205\240\n\313=\203G\211\202H\n\211\262\205\240\314 \204v\315\316\317\320!\321\"\203s\203s\305V\203s\322\323	\"\202t\324#\210\325\326 \327
\320!\205\204	\203\215	\202\223\206\223	\330\331#\266\202#\210\211\262
!\207" [last-input-event last-kbd-macro kmacro-call-repeat-key kmacro-call-repeat-with-arg this-single-command-keys 1 repeating kmacro-end-macro call-last-kbd-macro kmacro-loop-setup-function 0 t current-message message "(Type %s to repeat macro%s)" format-kbd-macro vector nil format " %d times" "" set-transient-map make-sparse-keymap define-key make-closure #[0 "\302\300\303\304\301$\207" [V0 V1 kmacro-call-macro repeating nil] 5 nil nil]] 16 (#$ . 16487) "p"])
#@940 Record subsequent keyboard input, defining a keyboard macro.
The commands are recorded even as they are executed.

Initializes the macro's `kmacro-counter' to ARG (or 0 if no prefix arg)
before defining the macro.

With \[universal-argument], appends to current keyboard macro (keeping
the current value of `kmacro-counter').

When used during defining/executing a macro, inserts the current value
of `kmacro-counter' and increments the counter value by ARG (or by 1 if no
prefix argument).  With just \[universal-argument], inserts the previous
value of `kmacro-counter', and does not modify the counter; this is
different from incrementing the counter by zero.  (The previous value
of the counter is the one it had before the last increment.)

The macro counter can be set directly via \[kmacro-set-counter] and \[kmacro-add-counter].
The format of the inserted value of the counter can be controlled
via \[kmacro-set-format].

(fn ARG)
(defalias 'kmacro-start-macro-or-insert-counter #[257 "\204	\203\f\302
!\207\303
!\207" [defining-kbd-macro executing-kbd-macro kmacro-insert-counter kmacro-start-macro] 3 (#$ . 17942) "P"])
#@215 End kbd macro if currently being defined; else call last kbd macro.
With numeric prefix ARG, repeat macro that many times.
With \[universal-argument], call second macro in macro ring.

(fn ARG &optional NO-REPEAT)
(defalias 'kmacro-end-or-call-macro #[513 "\203	\203\304\305#\207\306!\207\n\307=\203\"\203\"\310@\"\207
\203/
<\203/\311\312!\207\304\"\207" [defining-kbd-macro kmacro-call-repeat-key this-command kmacro-view-last-item kmacro-call-macro t kmacro-end-macro kmacro-view-macro kmacro-exec-ring-item kmacro-call-ring-2nd 1] 6 (#$ . 19083) "P"])
#@84 As `kmacro-end-or-call-macro' but allow repeat without repeating prefix.

(fn ARG)
(defalias 'kmacro-end-or-call-macro-repeat #[257 "\300 \301\302\"\210\211\205\303
!\207" [kmacro-get-repeat-prefix kmacro-end-or-call-macro t kmacro-repeat-on-last-key] 5 (#$ . 19662) "P"])
(put 'kmacro-end-or-call-macro-repeat 'kmacro-repeat 'head)
#@317 Call last keyboard macro, ending it first if currently being defined.
With numeric prefix ARG, repeat macro that many times.
Zero argument means repeat until there is an error.

To give a macro a name, so you can call it even after defining other
macros, use \[kmacro-name-last-macro].

(fn ARG &optional NO-REPEAT)
(defalias 'kmacro-end-and-call-macro #[513 "\203\301\302!\210\303\"\207" [defining-kbd-macro kmacro-end-macro nil kmacro-call-macro] 5 (#$ . 20005) "P"])
#@154 Move point to the position clicked with the mouse and call last kbd macro.
If kbd macro currently being defined end it before activating it.

(fn EVENT)
(defalias 'kmacro-end-call-mouse #[257 "\203&\303 \210	\203&	G\304U\203&\305\306\307!\210	\204&\n\203&\310 \210\202\311
!\210\312\305\313\"\207" [defining-kbd-macro last-kbd-macro kmacro-ring end-kbd-macro 0 nil message "Ignore empty macro" kmacro-pop-ring1 mouse-set-point kmacro-call-macro t] 4 (#$ . 20487) "e"])
#@89 Create lambda form for macro bound to symbol or key.

(fn MAC &optional COUNTER FORMAT)
(defalias 'kmacro-lambda-form #[769 "
\203E\202\f\300\301\"\207" [make-closure #[256 "\211\301=\203\n\301\300B\207\302\300\"\207" [V0 kmacro--extract-lambda kmacro-exec-ring-item] 4 "Keyboard macro.\n\n(fn &optional ARG)" "pkmacro"]] 7 (#$ . 20971)])
#@53 Extract kmacro from a kmacro lambda form.

(fn MAC)
(defalias 'kmacro-extract-lambda #[257 "\211\242\300=\203\301
\236\211\243\242\243\242\262
\2020\302
!\2050\303
!\304\232\2050\211\305!\211\242\305=\205.\211A\262
\211:\205D\211G\306U\205D\307
@!\205D\211\207" [lambda kmacro-exec-ring-item functionp interactive-form (interactive "pkmacro") kmacro--extract-lambda 3 arrayp] 4 (#$ . 21326)])
(defalias 'kmacro-p 'kmacro-extract-lambda "Return non-nil if MAC is a kmacro keyboard macro.")
#@629 When not defining or executing a macro, offer to bind last macro to a key.
The key sequences `C-x C-k 0' through `C-x C-k 9' and `C-x C-k A'
through `C-x C-k Z' are reserved for user bindings, and to bind to
one of these sequences, just enter the digit or letter, rather than
the whole sequence.

You can bind to any valid key sequence, but if you try to bind to
a key with an existing command binding, you will be asked for
confirmation whether to replace that binding.  Note that the
binding is made in the `global-map' keymap, so the macro binding
may be shaded by a local key binding.
The ARG parameter is unused.

(fn ARG)
(defalias 'kmacro-bind-to-key #[257 "\204	\203\205\212\304\305!\207\n\204\306\307!\210\310\311!\312\211G\313U\203M\314H\211\250\203L\211\315Y\2038\211\316X\204D\211\317Y\203L\211\320X\203L\321P\262\322\262\210\323\232?\205\210
\204y\324!\211\262\203y\211;\204y\325
!\204y\326\327\330\331!#!\205\210\332\333\334 !#\210\304\335\331!\"\266\203\207" [defining-kbd-macro executing-kbd-macro last-kbd-macro global-map message "Cannot save macro while defining it." error "No keyboard macro defined" read-key-sequence "Bind last macro to key: " nil 1 0 48 57 65 90 "" t "" key-binding vectorp yes-or-no-p format "%s runs command %S.  Bind anyway? " format-kbd-macro define-key kmacro-lambda-form kmacro-ring-head "Keyboard macro bound to %s"] 9 (#$ . 21831) "p"])
#@83 Return non-nil if SYMBOL is the name of some sort of keyboard macro.

(fn SYMBOL)
(defalias 'kmacro-keyboard-macro-p #[257 "\211K\211\205\211;\206\300
!\206\301
!\207" [vectorp kmacro-p] 4 (#$ . 23260)])
#@251 Assign a name to the last keyboard macro defined.
Argument SYMBOL is the name to define.
The symbol's function definition becomes the keyboard macro string.
Such a "function" cannot be called from Lisp, but it is a valid editor command.

(fn SYMBOL)
(defalias 'kmacro-name-last-macro #[257 "\204\301\302!\210\303
!\203\304
!\204\301\305\"\210\211\306\230\203#\301\307!\210\211\310\311 !M\210\312
\313\314#\207" [last-kbd-macro error "No keyboard macro defined" fboundp kmacro-keyboard-macro-p "Function %s is already defined and not a keyboard macro" "" "No command name given" kmacro-lambda-form kmacro-ring-head put kmacro t] 5 (#$ . 23477) "SName for last kbd macro: "])
#@74 compiler-macro for inlining `kmacro-register-p'.

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

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

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

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

(fn CL-WHOLE-ARG MACRO)
(defalias 'kmacro-make-register--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (macro) (cl-block kmacro-make-register (record 'kmacro-register macro)) nil] 9 (#$ . 25676)])
(put 'kmacro-make-register 'compiler-macro 'kmacro-make-register--cmacro)
#@64 Constructor for objects of type `kmacro-register'.

(fn MACRO)
(defalias 'kmacro-make-register #[257 "\300\301\"\207" [record kmacro-register] 4 (#$ . 26029)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\210\313\314\306\315\306\316%\210\313\317\306\320\306\321%\210\313\322\306\323\306\324%\207" [function-put kmacro-make-register side-effect-free t cl-struct-define kmacro-register nil cl-structure-object record ((cl-tag-slot) (macro)) cl-struct-kmacro-register-tags cl-generic-define-method register-val-jump-to ((data kmacro-register) _arg) #[514 "\302\303\211\304!	>\204\305\306\307D\"\210\310H$\207" [current-prefix-arg cl-struct-kmacro-register-tags kmacro-call-macro nil type-of signal wrong-type-argument kmacro-register 1] 10 "\n\n(fn DATA ARG)"] register-val-describe ((data kmacro-register) _verbose) #[514 "\301\302\303\304\305!>\204\306\307\310D\"\210\311H!\"!\207" [cl-struct-kmacro-register-tags princ format "a keyboard macro:\n   %s" format-kbd-macro type-of signal wrong-type-argument kmacro-register 1] 10 "\n\n(fn DATA VERBOSE)"] register-val-insert ((data kmacro-register)) #[257 "\301\302!>\204\303\304\305D\"\210
\306H!c\207" [cl-struct-kmacro-register-tags format-kbd-macro type-of signal wrong-type-argument kmacro-register 1] 6 "\n\n(fn DATA)"]] 11)
#@125 Store the last keyboard macro in register R.

Interactively, reads the register using `register-read-with-preview'.

(fn R)
(defalias 'kmacro-to-register #[257 "\301
\302\303\"\"\207" [last-kbd-macro set-register record kmacro-register] 6 (#$ . 27363) (byte-code "\204\301\302!\210\303\304!C\207" [last-kbd-macro error "No keyboard macro defined" register-read-with-preview "Save to register: "] 2)])
#@142 Display the last keyboard macro.
If repeated, it shows previous elements in the macro ring.
The ARG parameter is unused.

(fn &optional ARG)
(defalias 'kmacro-view-macro #[256 "\306 \204\307=\204\310\202+	\204\n\311\202+	:\203)	AT\202+\310\307\211\312	\203:	@@\202;
\310	\203]\311U\203J\313\202X\314U\203T\315\202X\316\317\"\320P\202^\321#\207" [last-command kmacro-view-last-item kmacro-ring kmacro-view-item-no this-command last-kbd-macro kmacro-ring-empty-p kmacro-view-macro nil 2 kmacro-display "2nd" 3 "3rd" format "%dth" " previous macro" "Last macro"] 8 (#$ . 27775) nil])
#@303 Display the last keyboard macro.
If repeated, it shows previous elements in the macro ring.
To execute the displayed macro ring item without changing the macro ring,
just enter C-k.
This is like `kmacro-view-macro', but allows repeating macro commands
without repeating the prefix.

(fn &optional ARG)
(defalias 'kmacro-view-macro-repeat #[256 "\301 \302!\210\205\211\205\303
!\207" [last-kbd-macro kmacro-get-repeat-prefix kmacro-view-macro kmacro-repeat-on-last-key] 4 (#$ . 28394) nil])
(put 'kmacro-view-macro-repeat 'kmacro-repeat 'ring)
#@47 Edit last keyboard macro.

(fn &optional ARG)
(defalias 'kmacro-edit-macro-repeat #[256 "\300\301\"\207" [edit-kbd-macro "
"] 4 (#$ . 28949) "P"])
(put 'kmacro-edit-macro-repeat 'kmacro-repeat 'stop)
#@86 As edit last keyboard macro, but without kmacro-repeat property.

(fn &optional ARG)
(defalias 'kmacro-edit-macro #[256 "\300\301\"\207" [edit-kbd-macro "
"] 4 (#$ . 29156) "P"])
#@54 Edit most recent 300 keystrokes as a keyboard macro.
(defalias 'kmacro-edit-lossage #[0 "\300 \210\301\302\303!@!\207" [kmacro-push-ring edit-kbd-macro where-is-internal view-lossage] 3 (#$ . 29342) nil])
(defvar kmacro-step-edit-active nil)
#@285 Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
This keymap is an extension to the `query-replace-map', allowing the
following additional answers: `insert', `insert-1', `replace', `replace-1',
`append', `append-end', `act-repeat', `skip-end', `skip-keep'.
(defvar kmacro-step-edit-map (byte-code "\301 \302
\"\210\303
\304\305#\210\303
\306\305#\210\303
\307\310#\210\303
\311\312#\210\303
\313\314#\210\303
\315\316#\210\303
\317\320#\210\303
\321\320#\210\303
\322\323#\210\303
\324\325#\210\303
\326\327#\210\303
\330\331#\210\303
\332\333#\210\303
\334\335#\210\207" [query-replace-map make-sparse-keymap set-keymap-parent define-key "	" act-repeat [tab] "" skip-rest "c" automatic "f" skip-keep "q" quit "d" skip "" "i" insert "I" insert-1 "r" replace "R" replace-1 "a" append "A" append-end] 5) (#$ . 29591))
#@20 

(fn MACRO INDEX)
(defalias 'kmacro-step-edit-prompt #[514 "?\205
\211\205


	O?\205	\306O\306\307 
\310\311\312\313\314\315\"\2032G\316V\2032\317\2023\320\321\n\203@\314!\202I\203H\322\202I\323\324\325#	\203U\317\202V\320\n\203b\314!\202c\320&\326 \203x\312\327\321\330\324\331#ed{#\202\212\203\211\312\327\321\332\324\331##\202\212\320\203\251\312\333\321\334\324\335#\f\203\236\336\202\237\320\321\337\324\340#
%\202\306\321\312\341$\247\203\266\320\202\267\342$\247\203\301\320\202\302\343#\324\340#Q\")\207" [kmacro-step-edit-appending executing-kbd-macro-index message-log-max kmacro-step-edit-new-macro kmacro-step-edit-help this-command nil current-message message "%s" format "Macro: %s%s%s%s%s\n" format-kbd-macro 1 0 " " "" propertize "<APPEND>" "<INSERT>" face region minibufferp "%s\n%s\n" "                         minibuffer                             " header-line "                         echo area                              " "%s\n%s%s %S [yn iIaArR C-k kq!] " "--------------Step Edit Keyboard Macro  [?: help]---------------" mode-line " Step: y/SPC: execute next,  d/n/DEL: skip next,  f: skip but keep\n       TAB: execute while same,  ?: toggle help\n Edit: i: insert,  r: replace,  a: append,  A: append at end,\n       I/R: insert/replace with one sequence,\n End:  !/c: execute rest,  C-k: skip rest and save,  q/C-g: quit\n----------------------------------------------------------------\n" "Next command:" bold "Type key sequence%s to insert and execute%s: " "s" " (end with C-j)" kmacro-step-edit-inserting] 18 (#$ . 30443)])
(defalias 'kmacro-step-edit-query #[0 "\306\307\211\211\310=\203.\f\306=\204.
\262\307\310\311!\210\203-
GZ\211\262
)\307\211\f\306=\203\201\310=\203y\312 \210\307\310\313!!\210\314 \315 \" \203l \311G[O 
GZ)\307\211!\316\262\202|\317\262\307\202\217\f=\203\215\317\262\202\217\307\204\250\320
\"\"\210\321#\322rpq\210\323 )!\"\262*\210\324\267\202Q
\202W
\202W
\307$\316%\202{
\202{
\316\202W
\316%\202{
\307%\306\262\202W
\"\325=\203\345\326\202\346\306&\202{
\327=\203\365\326\202\366\306&
GU\203{
\314\330\"\306'\202{
\306&
GU\203W
\314\331\"\306'\202W

GU\203=
\314\332\"\306\211&'\202@
\333%\306\262\202W
\"(?(\202{
\"\202{

\"V\203r
\314 \"\306=?\205n

O\" 
\203}

\202}
\316\211\211\"*\207" [kmacro-step-edit-mini-window-height max-mini-window-height resize-mini-windows this-command kmacro-step-edit-action executing-kbd-macro-index t nil quoted-insert 0 clear-this-command-keys prefix-numeric-value vconcat recent-keys ignore act kmacro-step-edit-prompt lookup-key vector read-event #s(hash-table size 15 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (act 176 act-repeat 179 quit 184 skip 193 skip-keep 196 skip-rest 201 automatic 207 exit 207 insert-1 216 insert 216 replace-1 235 replace 235 append 269 append-end 293 help 326)) insert-1 1 replace-1 [nil] [nil] [nil] append-end unread-command-events executing-kbd-macro defining-kbd-macro current-prefix-arg kmacro-step-edit-new-macro prefix-arg kmacro-step-edit-key-index kmacro-step-edit-map kmacro-step-edit-replace kmacro-step-edit-active kmacro-step-edit-inserting kmacro-step-edit-appending kmacro-step-edit-help] 12])
(defalias 'kmacro-step-edit-insert #[0 "\306	\307\211\211\211\211
\310\307\"\210\311\307\211\211\211\306%\262\312\306\307#\262\313\267\202v\202\227\314 \210\315\316!!\210\307\211\317\320 \"\262\247\203p\307\203p
\321G[O\262GZ\211\262
\307\322\262\202\235\247\203\202\307\202\235
\323\232\203\235\307\211
\262
\202\227\202\235\322\202\270\211\324>\203\255
\211GSH
\203\270\317\"\211\211,\207" [kmacro-step-edit-mini-window-height executing-kbd-macro defining-kbd-macro max-mini-window-height resize-mini-windows kmacro-step-edit-key-index t nil kmacro-step-edit-prompt read-key-sequence key-binding #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 49 quoted-insert 52)) clear-this-command-keys quoted-insert prefix-numeric-value vconcat recent-keys 0 ignore "\n" (self-insert-command digit-argument) executing-kbd-macro-index current-prefix-arg prefix-arg kmacro-step-edit-inserting unread-command-events kmacro-step-edit-action this-command last-command-event kmacro-step-edit-new-macro] 15])
(defalias 'kmacro-step-edit-pre-command #[0 "\306\307\310\"\210\203N\311\267\202)\312\202N\nGU\203N\313\314\"\315\211\315\202NU\204N\f\203;\316 \210\202>\317 \210
\203N\f\204N\320\312\315=\205Y\321\307\310\315#\207" [kmacro-step-edit-active this-command executing-kbd-macro-index executing-kbd-macro kmacro-step-edit-inserting kmacro-step-edit-appending remove-hook post-command-hook kmacro-step-edit-post-command #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ignore 15 append-end 20)) ignore vconcat [nil] t kmacro-step-edit-insert kmacro-step-edit-query nil add-hook kmacro-step-edit-num-input-keys num-input-keys] 5])
(defalias 'kmacro-step-edit-minibuf-setup #[0 "\301\302\303\304#\210\205\305\302\303\306\304$\207" [kmacro-step-edit-active remove-hook pre-command-hook kmacro-step-edit-pre-command t add-hook nil] 5])
(defalias 'kmacro-step-edit-post-command #[0 "\303\304\305\"\210\205\306\304\305\307\211$\210	\203	\211\207\n\211\207" [kmacro-step-edit-active kmacro-step-edit-key-index executing-kbd-macro-index remove-hook pre-command-hook kmacro-step-edit-pre-command add-hook nil] 5])
#@127 Step edit and execute last keyboard macro.

To customize possible responses, change the "bindings" in
`kmacro-step-edit-map'.
(defalias 'kmacro-step-edit-macro #[0 "\306\307\310\211\306\311\310\211	\n\312\301\313\310#\210\312\302\314\306#\210\312\303\315\306#\210\316\310\211\"\210\205Q\205Q\232?\205Q\317 \210\211.\f\207" [num-input-keys pre-command-hook post-command-hook minibuffer-setup-hook kmacro-step-edit-num-input-keys kmacro-step-edit-help t "" nil 0 add-hook kmacro-step-edit-pre-command kmacro-step-edit-post-command kmacro-step-edit-minibuf-setup call-last-kbd-macro kmacro-push-ring kmacro-step-edit-action kmacro-step-edit-key-index kmacro-step-edit-replace kmacro-step-edit-appending kmacro-step-edit-inserting kmacro-step-edit-new-macro kmacro-step-edit-active last-kbd-macro] 12 (#$ . 36078) nil])
#@50 Force redisplay during keyboard macro execution.
(defalias 'kmacro-redisplay #[0 "\204\f	\204\f\302\303!\210\205\304\305 )\207" [executing-kbd-macro defining-kbd-macro user-error "Not defining or executing keyboard macro" nil redisplay] 2 (#$ . 36936) nil])
(provide 'kmacro)