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



(byte-code "\301\302\303 \"\204\304\305\302#\210\301\207" [ctl-x-map where-is-internal vi-switch-mode current-local-map define-key "~"] 4)
#@77 Keymap used for \[vi-switch-mode] prefix key.  Link to various major modes.
(defvar vi-tilde-map nil (#$ . 226))
(byte-code "\204m\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\301\207" [vi-tilde-map make-keymap define-key "a" abbrev-mode "c" c-mode "d" vi-debugging "e" emacs-lisp-mode "f" auto-fill-mode "g" prolog-mode "h" hanoi "l" lisp-mode "n" nroff-mode "o" overwrite-mode "O" outline-mode "P" picture-mode "r" vi-readonly-mode "t" text-mode "v" vi-mode "x" tex-mode "~" vi-back-to-old-mode] 4)
#@112 Switch the major mode of current buffer as specified by the following char \{vi-tilde-map}

(fn ARG MODE-CHAR)
(defalias 'vi-switch-mode #[514 "\306\307!\"\211\204A	r\310\311!q\210p\312 \210
\313\211\314\211\314\315 \210\316\317!\210+\211\320\321\322!!\210rq\210\323 )\324!\210)\207\325
\313\"\210\326 \207" [vi-tilde-map default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks lookup-key char-to-string get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ substitute-command-keys "Possible major modes to switch to: \\{vi-tilde-map}" help-mode internal-temp-output-buffer-show command-execute force-mode-line-update inhibit-read-only standard-output prefix-arg] 9 (#$ . 1003) "P\nc"])
#@71 Toggle debug-on-error flag.  If prefix arg is given, set t.

(fn ARG)
(defalias 'vi-debugging #[257 "\211\203	\301\202\f?\203\302\303!\207\302\304!\207" [debug-on-error t message "Debug-on-error ..." "NO more debug-on-error"] 3 (#$ . 1810) "P"])
#@64 Go back to the previous mode without setting up for insertion.
(defalias 'vi-back-to-old-mode #[0 "\205	\306!\210
\307 \207" [vi-mode-old-major-mode vi-mode-old-mode-name mode-name vi-mode-old-local-map major-mode vi-mode-old-case-fold use-local-map force-mode-line-update case-fold-search] 2 (#$ . 2070) nil])
#@40 Toggle current buffer's readonly flag.
(defalias 'vi-readonly-mode #[0 "?\211\207" [buffer-read-only] 2 (#$ . 2396) nil])
#@128 Keymap used in Evi's command state
Command state includes most of the vi editing commands, with some Emacs
command extensions.
(defvar vi-com-map nil (#$ . 2527))
(byte-code "\301\302\303\304#\210\204\202\305 \306\307\310#\210\306\311\312#\210\306\313\314#\210\306\315\316#\210\306\317\320#\210\306\321\322#\210\306\323\324#\210\306\325\326#\210\306\327\330#\210\306\331\332#\210\306\333\334#\210\306\335\336#\210\306\337\340#\210\306\341\332#\210\306\342\343#\210\306\344\345#\210\306\346\347#\210\306\350\351#\210\306\352\353#\210\306\354\355#\210\306\356\357#\210\306\360\361#\210\306\362\363#\210\306\364\365#\210\306\366\367#\210\306\370\371#\210\306\372\373#\210\306\374\375#\210\306\376\377#\210\306\201@\201A#\210\306\201B\302#\210\306\201C\201D#\210\306\201E\201F#\210\306\201G\201H#\210\306\201I\201J#\210\306\201K\201L#\210\306\201M\201N#\210\306\201O\375#\210\306\201P\201Q#\210\306\201R\201S#\210\306\201T\201U#\210\306\201V\201W#\210\306\201X\340#\210\306\201Y\201Z#\210\306\201[\201\\#\210\306\201]\201^#\210\306\201_\201`#\210\306\201a\201b#\210\306\201c\201d#\210\306\201e\201d#\210\306\201f\201d#\210\306\201g\201d#\210\306\201h\201d#\210\306\201i\201d#\210\306\201j\201d#\210\306\201k\201d#\210\306\201l\201d#\210\306\201m\201n#\210\306\201o\201p#\210\306\201q\201F#\210\306\201r\201F#\210\306\201s\201F#\210\306\201t\201u#\210\306\201v\201w#\210\306\201x\201y#\210\306\201z\201{#\210\306\201|\201}#\210\306\201~\334#\210\306\201\201\200#\210\306\201\201\201\202#\210\306\201\203\201\204#\210\306\201\205\201\206#\210\306\201\207\201\210#\210\306\201\211\201\212#\210\306\201\213\302#\210\306\201\214\201\215#\210\306\201\216\201\217#\210\306\201\220\201\221#\210\306\201\222\201\223#\210\306\201\224\201\225#\210\306\201\226\201\227#\210\306\201\230\201\231#\210\306\201\232\201\233#\210\306\201\234\201\235#\210\306\201\236\375#\210\306\201\237\302#\210\306\201\240\201\241#\210\306\201\242\201\243#\210\306\201\244\201\245#\210\306\201\246\201\247 #\210\306\201\250\201\251#\210\306\201\252\375#\210\306\201\253\201F#\210\306\201\254\375#\210\306\201\255\201\256#\210\306\201\257\302#\210\306\201\260\201\261#\210\306\201\262\201\263#\210\306\201\264\201\265#\210\306\201\266\201F#\210\306\201\267\201F#\210\306\201\270\201\271#\210\306\201\272\201\273#\210\306\201\274\201\275#\210\306\201\276\201\277#\210\306\201\300\201\301#\210\306\201\302\332#\210\306\201\303\345#\210\306\201\304\201D#\210\306\201\305\201\306#\210\306\201\307\201\310#\210\306\201\311\201\312#\210\306\201\313\201\314#\210\306\201\315\201\316#\210\306\201\317\201\320#\210\306\201\321\201\322#\210\306\201\323\201\324#\210\306\201\325\201\326#\210\306\201\327\201\330#\210\306\201\331\201\332#\210\306\201\333\201\334#\210\306\201\335\201F#\210\306\201\336\201\337#\210\306\201\340\201\341#\210\306\201\342\201\343#\210\306\201\344\201\345#\210\306\201\346\201\347#\210\306\201\350\201\351#\210\301\201\277\201\352\201\353#\210\301\332\201\352\201\354#\210\301\201\355\201\352\201\354#\210\301\201\356\201\352\201\354#\210\301\345\201\352\201\354#\210\301\351\201\352\201\357#\210\301\201u\201\352\201\357#\210\301\353\201\352\201\357#\210\301\201`\201\352\201\357#\210\301\201D\201\352\201\353#\210\301\201L\201\352\201\353#\210\301\201N\201\352\201\360#\210\301\201Q\201\352\201\354#\210\301\201S\201\352\201\361#\210\301\201U\201\352\201\361#\210\301\340\201\352\201\354#\210\301\201\\\201\352\201\354#\210\301\201Z\201\352\201\362#\210\301\201\363\201\352\201\357#\210\301\201b\201\352\201\353#\210\301\201\275\201\352\201\353#\210\301\201p\201\352\201\364#\210\301\201\365\201\352\201\357#\210\301\201{\201\352\201\366#\210\301\201\200\201\352\201\360#\210\301\201\202\201\352\201\364#\210\301\201\204\201\352\201\354#\210\301\201\206\201\352\201\354#\210\301\201\215\201\352\201\354#\210\301\201\217\201\352\201\354#\210\301\201\221\201\352\201\367#\210\301\201\235\201\352\201\364#\210\301\201\241\201\352\201\366#\210\301\201\256\201\352\201\353#\210\301\201\261\201\352\201\353#\210\301\201\265\201\352\201\370#\210\301\201\271\201\352\201\360#\210\301\201\273\201\352\201\364#\210\301\201\277\201\352\201\353#\210\301\201\371\201\352\201\353#\210\301\201\310\201\352\201\357#\210\301\201\324\201\352\201\364#\210\301\201\332\201\352\201\370#\210\301\201\343\201\352\201\360#\210\301\201\345\201\352\201\372#\210\301\201\341\201\352\201\372#\210\301\201\373\201\352\201\374#\210\301\201\375\201\352\201\374#\210\301\201\376\201\352\201\374#\210\301\201\377\201\352\201\374#\210\301\201
\201\352\201\374#\210\301\201

\201\352\201\374#\210\301\201
\201\352\201\374#\210\301\201
\201\352\201\374#\207" [vi-com-map put vi-undefined suppress-keymap t make-keymap define-key "" vi-mark-region "
" vi-ask-for-info "" vi-backward-windowful "" vi-do-old-mode-C-c-command "" vi-scroll-down-window "" vi-expose-line-below "" vi-forward-windowful "" keyboard-quit "	" indent-relative-first-indent-point "\n" vi-next-line "" vi-kill-line "\f" recenter "
" vi-next-line-first-nonwhite "" "" vi-split-open-line "" previous-line "" vi-query-replace "" vi-isearch-backward "" vi-isearch-forward "" vi-transpose-objects "" vi-scroll-up-window "" scroll-up-command "" vi-kill-region "" Control-X-prefix "" vi-expose-line-above "" suspend-emacs "" ESC-prefix "" vi-unimplemented "" xref-find-definitions "" vi-locate-def "" " " forward-char "!" vi-operator "\"" vi-char-argument "#" universal-argument "$" end-of-line "%" vi-find-matching-paren "&" "'" vi-goto-line-mark "(" backward-sexp ")" forward-sexp "*" vi-name-last-change-or-macro "+" "," vi-reverse-last-find-char "-" vi-previous-line-first-nonwhite "." vi-redo-last-change-command "/" vi-search-forward "0" beginning-of-line "1" vi-digit-argument "2" "3" "4" "5" "6" "7" "8" "9" ":" vi-ex-cmd ";" vi-repeat-last-find-char "<" "=" ">" "?" vi-search-backward "@" vi-call-named-change-or-macro "A" vi-append-at-end-of-line "B" vi-backward-blank-delimited-word "C" vi-change-rest-of-line "D" "E" vi-end-of-blank-delimited-word "F" vi-backward-find-char "G" vi-goto-line "H" vi-home-window-line "I" vi-insert-before-first-nonwhite "J" vi-join-lines "K" "L" vi-last-window-line "M" vi-middle-window-line "N" vi-reverse-last-search "O" vi-open-above "P" vi-put-before "Q" vi-quote-words "R" vi-replace-chars "S" vi-substitute-lines "T" vi-backward-upto-char "U" "V" "W" vi-forward-blank-delimited-word "X" call-last-kbd-macro "Y" vi-yank-line "Z" make-sparse-keymap "ZZ" vi-save-all-and-exit "[" "\\" "]" "^" back-to-indentation "_" "`" vi-goto-char-mark "a" vi-insert-after "b" backward-word "c" "d" "e" vi-end-of-word "f" vi-forward-find-char "g" vi-beginning-of-buffer "h" backward-char "i" vi-insert-before "j" "k" "l" "m" vi-set-mark "n" vi-repeat-last-search "o" vi-open-below "p" vi-put-after "q" vi-replace "r" vi-replace-1-char "s" vi-substitute-chars "t" vi-forward-upto-char "u" undo "v" vi-verify-spelling "w" vi-forward-word "x" vi-kill-char "y" "z" vi-adjust-window "{" backward-paragraph "|" vi-goto-column "}" forward-paragraph "~" vi-change-case "" delete-backward-char point-moving-unit char line next-line forward-line search match sexp rev-find vi-re-search-forward find vi-re-search-backward WORD rev-search word vi-forward-char paragraph mark-page region mark-paragraph mark-word mark-sexp mark-defun mark-whole-buffer mark-end-of-sentence c-mark-function] 4)
#@57 Alist of (NAME . MARK), marks are local to each buffer.
(defvar vi-mark-alist nil (#$ . 10355))
#@60 Default amount of lines for scrolling (used by "^D"/"^U").
(defvar vi-scroll-amount (byte-code "\300 \301\245\207" [window-height 2] 2) (#$ . 10457))
#@37 Shift amount for "<"/">" operators.
(defvar vi-shift-width 4 (#$ . 10613))
#@51 Last insertion point.  Should use `mark' instead.
(defvar vi-ins-point nil (#$ . 10694))
#@27 Length of last insertion.
(defvar vi-ins-length nil (#$ . 10789))
#@45 The repetition required for last insertion.
(defvar vi-ins-repetition nil (#$ . 10861))
#@45 T if last insertion was a replace actually.
(defvar vi-ins-overwrt-p nil (#$ . 10955))
#@52 Code to be eval'ed before (redo-)insertion begins.
(defvar vi-ins-prefix-code nil (#$ . 11048))
#@64 Save last direction, char and upto-flag used for char finding.
(defvar vi-last-find-char nil (#$ . 11150))
#@111 Save commands for redoing last changes.  Each command is in (FUNC . ARGS)
form that is ready to be `apply'ed.
(defvar vi-last-change-command nil (#$ . 11264))
#@49 Save last shell command given for "!" operator.
(defvar vi-last-shell-command nil (#$ . 11429))
#@35 Non-nil if it is in insert state.
(defvar vi-insert-state nil (#$ . 11531))
#@45 Save last search command for possible redo.
(defvar vi-search-last-command nil (#$ . 11613))
#@50 Save the local-map used before entering vi-mode.
(defvar vi-mode-old-local-map nil (#$ . 11712))
#@45 Save the mode-name before entering vi-mode.
(defvar vi-mode-old-mode-name nil (#$ . 11815))
#@46 Save the major-mode before entering vi-mode.
(defvar vi-mode-old-major-mode nil (#$ . 11913))
(defvar vi-mode-old-case-fold nil)
#@74 Setup a buffer for vi-mode by creating necessary buffer-local variables.
(defalias 'vi-mode-setup #[0 "\302\300!\210\303 \304\245\302\301!\210\305\302\306!\210\302\307!\210\302\310!\210\302\311!\210\302\312!\210\302\313!\210\302\314!\210\302\315!\210\302\316!\210\302\317!\210\302\320!\210\302\321!\210\302\322!\210\302\323!\210\324\325!\207" [vi-scroll-amount vi-shift-width make-local-variable window-height 2 4 vi-ins-point vi-ins-length vi-ins-repetition vi-ins-overwrt-p vi-ins-prefix-code vi-last-change-command vi-last-shell-command vi-last-find-char vi-mark-alist vi-insert-state vi-mode-old-local-map vi-mode-old-mode-name vi-mode-old-major-mode vi-mode-old-case-fold run-mode-hooks vi-mode-hook] 2 (#$ . 12048)])
#@2273 Major mode that acts like the `vi' editor.
The purpose of this mode is to provide you the combined power of vi (namely,
the "cross product" effect of commands and repeat last changes) and Emacs.

This command redefines nearly all keys to look like vi commands.
It records the previous major mode, and any vi command for input
(`i', `a', `s', etc.) switches back to that mode.
Thus, ordinary Emacs (in whatever major mode you had been using)
is "input" mode as far as vi is concerned.

To get back into vi from "input" mode, you must issue this command again.
Therefore, it is recommended that you assign it to a key.

Major differences between this mode and real vi :

* Limitations and unsupported features
  - Search patterns with line offset (e.g. /pat/+3 or /pat/z.) are
    not supported.
  - Ex commands are not implemented; try ':' to get some hints.
  - No line undo (i.e. the `U' command), but multi-undo is a standard feature.

* Modifications
  - The stopping positions for some point motion commands (word boundary,
    pattern search) are slightly different from standard `vi'.
    Also, no automatic wrap around at end of buffer for pattern searching.
  - Since changes are done in two steps (deletion then insertion), you need
    to undo twice to completely undo a change command.  But this is not needed
    for undoing a repeated change command.
  - No need to set/unset `magic', to search for a string with regular expr
    in it just put a prefix arg for the search commands.  Replace cmds too.
  - ^R is bound to incremental backward search, so use ^L to redraw screen.

* Extensions
  - Some standard (or modified) Emacs commands were integrated, such as
    incremental search, query replace, transpose objects, and keyboard macros.
  - In command state, ^X links to the `ctl-x-map', and ESC can be linked to
    esc-map or set undefined.  These can give you the full power of Emacs.
  - See vi-com-map for those keys that are extensions to standard vi, e.g.
    `vi-name-last-change-or-macro', `vi-verify-spelling', `vi-locate-def',
    `vi-mark-region', and `vi-quote-words'.  Some of them are quite handy.
  - Use \[vi-switch-mode] to switch among different modes quickly.

Syntax table and abbrevs while in vi mode remain as they were in Emacs.
(defalias 'vi-mode #[0 "\204\306 \210	\307=\203\310 \210\311\312!\207\313 	
\314\315!\210\307\316\317 \210\2053\320 \207" [vi-mode-old-major-mode major-mode vi-mode-old-local-map mode-name vi-mode-old-mode-name case-fold-search vi-mode-setup vi-mode ding message "Already in vi-mode." current-local-map nil use-local-map "VI" force-mode-line-update vi-end-of-insert-state vi-mode-old-case-fold vi-com-map vi-insert-state] 2 (#$ . 12781) nil])
#@8 Ding !
(defalias 'vi-ding #[0 "\300 \207" [ding] 1 (#$ . 15520) nil])
#@61 Save all modified buffers without asking, then exits emacs.
(defalias 'vi-save-all-and-exit #[0 "\300\301!\210\302 \207" [save-some-buffers t kill-emacs] 2 (#$ . 15596) nil])
(defvar vi-replaced-string nil)
(defvar vi-replacing-string nil)
#@495 Ex commands are not implemented in Evi mode.  For some commonly used ex
commands, you can use the following alternatives for similar effect :
w            C-x C-s (save-buffer)
wq           C-x C-c (save-buffers-kill-emacs)
w fname      C-x C-w (write-file)
e fname      C-x C-f (find-file)
r fname      C-x i   (insert-file)
s/old/new    use q (vi-replace) to do unconditional replace
             use C-q (vi-query-replace) to do query replace
set sw=n     M-x set-variable vi-shift-width n 
(defalias 'vi-ex-cmd #[0 "r\306\307!q\210p\310 \210
\311\211\312\211\312\313 \210\314\315!\210+\211\316\317\320!!\210rq\210\321 )\322!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ documentation vi-ex-cmd help-mode internal-temp-output-buffer-show standard-output] 6 (#$ . 15843) nil])
(defalias 'vi-undefined #[0 "\301\302\303!\"\210\304 \207" [last-command-event message "Command key \"%s\" is undefined in Evi." single-key-description ding] 4 nil nil])
(defalias 'vi-unimplemented #[0 "\301\302\303!\"\210\304 \207" [last-command-event message "Command key \"%s\" is not implemented in Evi." single-key-description ding] 4 nil nil])
#@342 Go into insert state, the text entered will be repeated if REPETITION > 1.
If PREFIX-CODE is given, do it before insertion begins if DO-IT-NOW-P is T.
In any case, the prefix-code will be done before each `redo-insert'.
This function expects `overwrite-mode' being set properly beforehand.

(fn REPETITION &optional PREFIX-CODE DO-IT-NOW-P)
(defalias 'vi-goto-insert-state #[769 "\211\203\306@A\"\210`

\n\307!\210\f
\310 \210\311\211\207" [vi-ins-point vi-ins-repetition vi-ins-prefix-code vi-mode-old-mode-name mode-name vi-mode-old-case-fold apply use-local-map force-mode-line-update t case-fold-search vi-mode-old-local-map vi-mode-old-major-mode major-mode vi-insert-state] 6 (#$ . 17183)])
#@53 Terminate insertion and set up last change command.
(defalias 'vi-end-of-insert-state #[0 "`W\204`U\203	\203\n\304X\203\305\306!\207\n\307V\2034`{\n\307V\2033\211c\210\nS\211\202$\210\310\311`	%\210\305\306!\207" [vi-ins-point vi-ins-prefix-code vi-ins-repetition overwrite-mode 0 vi-goto-command-state t 1 vi-set-last-change-command vi-first-redo-insertion] 7 (#$ . 17903)])
#@198 Redo last insertion the first time.  Extract the string and save it for
future redoes.  Do prefix-code if it's given, use overwrite mode if asked.

(fn BEGIN END &optional OVERWRITE-P PREFIX-CODE)
(defalias 'vi-first-redo-insertion #[1026 "{
\203\300@A\"\210\203``G\\|\210\211c\210\301\302$\207" [apply vi-set-last-change-command vi-more-redo-insertion] 10 (#$ . 18303)])
#@179 Redo more insertion : copy string from STR to point, use overwrite mode
if overwrite-p is T; apply prefix-code first if it's non-nil.

(fn STR &optional OVERWRITE-P PREFIX-CODE)
(defalias 'vi-more-redo-insertion #[769 "\211\203\300
@A\"\210
\203``G\\|\210c\207" [apply] 6 (#$ . 18695)])
#@123 Go to vi-mode command state.  If optional arg exists, means return from
insert state.

(fn &optional FROM-INSERT-STATE-P)
(defalias 'vi-goto-command-state #[256 "\303!\210\304\211\205\n\205\302\305!\207" [vi-com-map vi-insert-state overwrite-mode use-local-map nil 0] 3 (#$ . 18996)])
#@78 kill specified number of lines (=d$), text saved in the kill ring.

(fn ARG)
(defalias 'vi-kill-line #[257 "\300
!\210\301\300\"\207" [kill-line vi-set-last-change-command] 4 (#$ . 19293) "*P"])
#@18 

(fn START END)
(defalias 'vi-kill-region #[514 "\300\"\210\301\300!\207" [kill-region vi-set-last-change-command] 5 (#$ . 19495) "*r"])
#@63 go to end of line and then go into vi insert state.

(fn ARG)
(defalias 'vi-append-at-end-of-line #[257 "\300
\301\302#\207" [vi-goto-insert-state (end-of-line) t] 5 (#$ . 19641) "*p"])
#@56 Change the rest of (ARG) lines (= c$ in vi).

(fn ARG)
(defalias 'vi-change-rest-of-line #[257 "\300\301\302D\303#\207" [vi-goto-insert-state 1 kill-line t] 5 (#$ . 19833) "*P"])
#@24 (= ^i in vi)

(fn ARG)
(defalias 'vi-insert-before-first-nonwhite #[257 "\300
\301\302#\207" [vi-goto-insert-state (back-to-indentation) t] 5 (#$ . 20019) "*p"])
#@71 open new line(s) above current line and enter insert state.

(fn ARG)
(defalias 'vi-open-above #[257 "\300\301\302D\303#\207" [vi-goto-insert-state 1 #[257 "\300 \206\301
!\207" [beginning-of-line open-line] 3 "\n\n(fn X)"] t] 5 (#$ . 20187) "*p"])
#@70 open new line(s) and go into insert mode on the last line.

(fn ARG)
(defalias 'vi-open-below #[257 "\300\301\302D\303#\207" [vi-goto-insert-state 1 #[257 "\300\206
\301
!\206
\211y\207" [nil open-line] 3 "\n\n(fn X)"] t] 5 (#$ . 20445) "*p"])
#@47 start vi insert state after cursor.

(fn ARG)
(defalias 'vi-insert-after #[257 "\300
\301C\302#\207" [vi-goto-insert-state #[0 "l?\205\300u\207" [nil] 1] t] 5 (#$ . 20699) "*p"])
#@49 enter insert state before the cursor.

(fn ARG)
(defalias 'vi-insert-before #[257 "\300
!\207" [vi-goto-insert-state] 3 (#$ . 20886) "*p"])
#@29 Go to ARGth line.

(fn ARG)
(defalias 'vi-goto-line #[257 "\300
!\204	\301 \207\302\303!!\207" [vi-raw-numeric-prefix end-of-buffer goto-line vi-prefix-numeric-value] 4 (#$ . 21032) "P"])
#@48 Move point to the beginning of current buffer.
(defalias 'vi-beginning-of-buffer #[0 "eb\207" [] 1 (#$ . 21228) nil])
#@78 Incremental search forward.  Use regexp version if ARG is non-nil.

(fn ARG)
(defalias 'vi-isearch-forward #[257 "\211\203\301\202	\302`\303!\210\211`U?\205 \203\304\202\305\211\207" [vi-search-last-command isearch-forward-regexp isearch-forward call-interactively re-search-forward search-forward] 5 (#$ . 21352) "P"])
#@79 Incremental search backward.  Use regexp version if ARG is non-nil.

(fn ARG)
(defalias 'vi-isearch-backward #[257 "\211\203\301\202	\302`\303!\210\211`U?\205 \203\304\202\305\211\207" [vi-search-last-command isearch-backward-regexp isearch-backward call-interactively re-search-backward search-backward] 5 (#$ . 21689) "P"])
#@87 Nonincremental search forward. Use regexp version if ARG is non-nil.

(fn ARG STRING)
(defalias 'vi-search-forward #[514 "
\203\301\202	\302\211G\303V\203\304
\"\210
\305\211\306$\207" [vi-search-last-command re-search-forward search-forward 0 isearch-update-ring nil 1] 7 (#$ . 22032) (byte-code "\203\301\302\303\304\"D\207\304\302\305\304\"D\207" [current-prefix-arg t read-string "regexp/" nil "/"] 4)])
#@89 Nonincremental search backward.  Use regexp version if ARG is non-nil.

(fn ARG STRING)
(defalias 'vi-search-backward #[514 "
\203\301\202	\302\211G\303V\203\304
\"\210
\305\211\306$\207" [vi-search-last-command re-search-backward search-backward 0 isearch-update-ring nil 1] 7 (#$ . 22457) (byte-code "\203\301\302\303\304\"D\207\304\302\305\304\"D\207" [current-prefix-arg t read-string "regexp?" nil "?"] 4)])
#@160 Repeat last search command.
If optional search-command/string are given,
use those instead of the ones saved.

(fn ARG &optional SEARCH-COMMAND SEARCH-STRING)
(defalias 'vi-repeat-last-search #[769 "
\204\262\211\204
\303>\203	\202\n@\262

\204$\304 \210\305\306!\207

\307\211$\207" [vi-search-last-command regexp-search-ring search-ring (re-search-forward re-search-backward) ding message "No last search command to repeat." nil] 8 (#$ . 22888) "p"])
#@173 Redo last search command in reverse direction.
If the optional search args are given, use those instead of the ones saved.

(fn ARG &optional SEARCH-COMMAND SEARCH-STRING)
(defalias 'vi-reverse-last-search #[769 "
\204\262\211\204
\303>\203	\202\n@\262

\204$\304 \210\305\306!\207
\307\267\202:\310\202;\311\202;\312\202;\313\202;\314
\314\211$\207" [vi-search-last-command regexp-search-ring search-ring (re-search-forward re-search-backward) ding message "No last search command to repeat." #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (re-search-forward 42 re-search-backward 46 search-forward 50 search-backward 54)) re-search-backward re-search-forward search-backward search-forward nil] 8 (#$ . 23361) "p"])
#@82 join ARG lines from current line (default 2), cleaning up white space.

(fn ARG)
(defalias 'vi-join-lines #[257 "\300
!\204
\301\302!\210\202\"\303
!\211\304Y\203!\301\302!\210\211S\262
\202\210\305\306\"\207" [vi-raw-numeric-prefix delete-indentation t vi-prefix-numeric-value 2 vi-set-last-change-command vi-join-lines] 4 (#$ . 24141) "P"])
#@53 kill the current line.  Only works in insert state.
(defalias 'vi-backward-kill-line #[0 "\205\301\302!\210\303\304!\207" [vi-insert-state beginning-of-line 1 kill-line nil] 2 (#$ . 24496) nil])
#@70 abort insert state, kill inserted text and go back to command state.
(defalias 'vi-abort-ins #[0 "\205`	V\203\302	`\"\210\303\304!\207" [vi-insert-state vi-ins-point kill-region vi-goto-command-state t] 3 (#$ . 24700) nil])
#@56 Backward COUNT windowfuls. Default is one.

(fn COUNT)
(defalias 'vi-backward-windowful #[257 "\211\300V\205\301\302!\210\211S\262
\202\207" [0 scroll-down nil] 3 (#$ . 24935) "p"])
#@164 Scrolls down window COUNT lines.
If COUNT is nil (actually, non-integer), scrolls default amount.
The given COUNT is remembered for future scrollings.

(fn COUNT)
(defalias 'vi-scroll-down-window #[257 "\211\250\203\211\301!\207" [vi-scroll-amount scroll-up] 3 (#$ . 25128) "P"])
#@84 Expose COUNT more lines below the current window.  Default COUNT is 1.

(fn COUNT)
(defalias 'vi-expose-line-below #[257 "\300
!\207" [scroll-up] 3 (#$ . 25418) "p"])
#@55 Forward COUNT windowfuls. Default is one.

(fn COUNT)
(defalias 'vi-forward-windowful #[257 "\211\300V\205\301\302!\210\211S\262
\202\207" [0 scroll-up nil] 3 (#$ . 25591) "p"])
#@66 Go down count lines, try to keep at the same column.

(fn COUNT)
(defalias 'vi-next-line #[257 "\302`\303!\210`U\203\304 \207\302\211\207" [this-command last-command next-line line-move ding] 4 (#$ . 25779) "p"])
#@60 Go down COUNT lines.  Stop at first non-white.

(fn COUNT)
(defalias 'vi-next-line-first-nonwhite #[257 "`
y\210\300 \210`U\205\301 \207" [back-to-indentation ding] 3 (#$ . 26003) "p"])
#@58 Go up COUNT lines.  Stop at first non-white.

(fn COUNT)
(defalias 'vi-previous-line-first-nonwhite #[257 "\211[y\210\300 \207" [back-to-indentation] 2 (#$ . 26197) "p"])
#@162 Scrolls up window COUNT lines.
If COUNT is nil (actually, non-integer), scrolls default amount.
The given COUNT is remembered for future scrollings.

(fn COUNT)
(defalias 'vi-scroll-up-window #[257 "\211\250\203\211\301!\207" [vi-scroll-amount scroll-down] 3 (#$ . 26375) "P"])
#@84 Expose COUNT more lines above the current window.  Default COUNT is 1.

(fn COUNT)
(defalias 'vi-expose-line-above #[257 "\300
!\207" [scroll-down] 3 (#$ . 26663) "p"])
#@165 Get following character (could be any CHAR) as part of the prefix argument.
Possible prefix-arg cases are nil, INTEGER, (nil . CHAR) or (INTEGER . CHAR).

(fn ARG)
(defalias 'vi-char-argument #[257 "\301 
\204\f\302
B\211\207
\250\203

B\211\207
@
B\211\207" [prefix-arg read-char nil] 4 (#$ . 26839) "P"])
#@161 Go to marked position or line (if line-flag is given).
Goto mark `@' means jump into and pop the top mark on the mark ring.

(fn MARK-CHAR &optional LINE-FLAG)
(defalias 'vi-goto-mark #[513 "\301\"\203\302 \210\211\205B\303 \207\301\304\"\203#\305\306!\210\211\205B\303 \207\307!\211\2043\310 \210\311\312!\202@\305\313!\210\211b\210
\205@\303 \262
\207" [last-command-event char-equal exchange-point-and-mark back-to-indentation 64 set-mark-command t vi-get-mark vi-ding message "Mark register undefined." nil] 5 (#$ . 27159)])
#@69 Go to the line (at first non-white) marked by next char.

(fn CHAR)
(defalias 'vi-goto-line-mark #[257 "\300
\301\"\207" [vi-goto-mark t] 4 (#$ . 27706) "c"])
#@62 Go to the char position marked by next mark-char.

(fn CHAR)
(defalias 'vi-goto-char-mark #[257 "\300
!\207" [vi-goto-mark] 3 (#$ . 27871) "c"])
#@40 Set numeric prefix argument.

(fn ARG)
(defalias 'vi-digit-argument #[257 "\211\204\301
!\207\211\250\203\301\302!\210
_\211\207\301\302!\210
@\204%\303\202'
@_
AB\211\207" [prefix-arg digit-argument nil 1] 3 (#$ . 28022) "P"])
#@65 Return the raw value of numeric part prefix argument.

(fn ARG)
(defalias 'vi-raw-numeric-prefix #[257 "\211:\203\211@\207\207" [] 2 (#$ . 28266)])
#@158 Return numeric meaning of the raw prefix argument.  This is a modification
to the standard one provided in `callint.c' to handle (_ . CHAR) cases.

(fn ARG)
(defalias 'vi-prefix-numeric-value #[257 "\211\204\300\207\211\250\203\f\207\211:\205\211@\203\211@\207\300\207" [1] 2 (#$ . 28423)])
#@149 Reverse last f F t T operation COUNT times.  If the optional FIND-ARG
is given, it is used instead of the saved one.

(fn COUNT &optional FIND-ARG)
(defalias 'vi-reverse-last-find-char #[513 "\211\204\262
\211\204\301 \210\302\303!\207\304
@\305_AB\"\207" [vi-last-find-char ding message "No last find char to repeat." vi-find-char -1] 5 (#$ . 28728) "p"])
#@160 Find in DIRECTION (1/-1) for CHAR of COUNT'th times on current line.
If UPTO-FLAG is T, stop before the char. ARG = (DIRECTION.CHAR.UPTO-FLAG.

(fn ARG COUNT)
(defalias 'vi-find-char #[514 "
@A@AA`\\\3002Y\211f\204\301\300\302\"\210\202Q\303
f\304\"\203,\301\300\302\"\210\202Q\303f\"\203QS\262\305U\203Q\301\300\203NZ\211\262\202O\"\210\211\\\262
\202\203_\211b\207\306 \207" [exit-find-char throw nil char-equal 10 0 ding] 10 (#$ . 29099)])
#@144 Repeat last f F t T operation COUNT times.  If optional FIND-ARG is given,
it is used instead of the saved one.

(fn COUNT &optional FIND-ARG)
(defalias 'vi-repeat-last-find-char #[513 "\211\204\262
\211\204\301 \210\302\303!\207\304
\"\207" [vi-last-find-char ding message "No last find char to repeat." vi-find-char] 5 (#$ . 29577) "p"])
#@67 Find the COUNT'th CHAR backward on current line.

(fn COUNT CHAR)
(defalias 'vi-backward-find-char #[514 "\301
CB\302!\207" [vi-last-find-char -1 vi-repeat-last-find-char] 4 (#$ . 29929) "p\nc"])
#@66 Find the COUNT'th CHAR forward on current line.

(fn COUNT CHAR)
(defalias 'vi-forward-find-char #[514 "\301
CB\302!\207" [vi-last-find-char 1 vi-repeat-last-find-char] 4 (#$ . 30133) "p\nc"])
#@72 Find upto the COUNT'th CHAR backward on current line.

(fn COUNT CHAR)
(defalias 'vi-backward-upto-char #[514 "\301
\302BB\303!\207" [vi-last-find-char -1 t vi-repeat-last-find-char] 5 (#$ . 30334) "p\nc"])
#@71 Find upto the COUNT'th CHAR forward on current line.

(fn COUNT CHAR)
(defalias 'vi-forward-upto-char #[514 "\301
\302BB\303!\207" [vi-last-find-char 1 t vi-repeat-last-find-char] 5 (#$ . 30549) "p\nc"])
#@104 Move forward until encountering the end of a word.
With argument, do this that many times.

(fn COUNT)
(defalias 'vi-end-of-word #[257 "m\204\300u\210\301\302\300\303$\205\304u\207" [nil re-search-forward "\\W*\\w+\\>" t -1] 6 (#$ . 30762) "p"])
#@73 Replace char after point by CHAR.  Repeat COUNT times.

(fn COUNT CHAR)
(defalias 'vi-replace-1-char #[514 "\301\302\"\210\211\303!\210\304\305#\207" [last-command-event delete-char nil self-insert-command vi-set-last-change-command vi-replace-1-char] 6 (#$ . 31019) "p\nc"])
#@40 Replace chars over old ones.

(fn ARG)
(defalias 'vi-replace-chars #[257 "\300\301!\210\302
!\207" [overwrite-mode 1 vi-goto-insert-state] 3 (#$ . 31306) "*p"])
#@76 Substitute COUNT chars by the input chars, enter insert state.

(fn COUNT)
(defalias 'vi-substitute-chars #[257 "\300\301\302D\303#\207" [vi-goto-insert-state 1 #[257 "``\\|\207" [] 4 "\n\n(fn C)"] t] 5 (#$ . 31473) "*p"])
#@68 Substitute COUNT lines by the input chars. (=cc in vi)

(fn COUNT)
(defalias 'vi-substitute-lines #[257 "\300\301\302\303SE\304#\207" [vi-goto-insert-state 1 vi-delete-op next-line t] 6 (#$ . 31704) "*p"])
#@61 Get the char part of the current prefix argument.

(fn ARG)
(defalias 'vi-prefix-char-value #[257 "\211\204\300\207\211\250\203
\300\207\211:\203\211A\207\300\207" [nil] 2 (#$ . 31917)])
#@130 Handling vi operators (d/c/</>/!/=/y).  Current implementation requires
the key bindings of the operators being fixed.

(fn ARG)
(defalias 'vi-operator #[257 "\3042F\305 \306	\307!\"\211\310=\204
\202(\310!\210\305 \306	\307!\"\311
\"\203>\312
\313\314!S\315!B#\202C\312
\n#\262
0\207" [last-command-event vi-com-map this-command prefix-arg vi-exit-op read-char lookup-key char-to-string vi-digit-argument char-equal vi-execute-op next-line vi-prefix-numeric-value vi-prefix-char-value] 9 (#$ . 32116) "P"])
#@153 Execute vi edit operator as specified by OP-CHAR, the operand is the region
determined by the MOTION-COMMAND with ARG.

(fn OP-CHAR MOTION-COMMAND ARG)
(defalias 'vi-execute-op #[771 "\302U\203\303\"\205\247\304\303\305!#\207\306U\203-\303\"\205\247\307\310\303\305!E\311#\207\312U\203B\313\"\205\247\304\313\305!#\207\314U\203X\315\"\205\247\304\315\305!$\207\316U\203q\317	[#\205\247\304\317\305!	[$\207\320U\203\210\317	#\205\247\304\317\305!	$\207\321U\203\235\322\"\205\247\304\322\305!#\207\323U\205\247\324\"\207" [vi-last-shell-command vi-shift-width 100 vi-delete-op vi-set-last-change-command vi-repeat-command-of 99 vi-goto-insert-state 1 nil 121 vi-yank-op 33 vi-shell-op 60 vi-shift-op 62 61 vi-indent-op 92 vi-narrow-op] 8 (#$ . 32650)])
#@62 Return the command for redo the given command.

(fn COMMAND)
(defalias 'vi-repeat-command-of #[257 "\211\300N\211\301\267\202
\302\207\303\207
\207" [point-moving-unit #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (search 9 find 11)) vi-repeat-last-search vi-repeat-last-find-char] 4 (#$ . 33463)])
#@183 Return (begin . end) of the range spanned by executing the given
MOTION-COMMAND with ARG.
   MOTION-COMMAND in ready-to-eval list form is not yet supported.

(fn MOTION-COMMAND ARG)
(defalias 'vi-effective-range #[514 "\212`\301\211\302N`\262\303\301\"\210`U\203&\211\304=\204&
\211B\266\204\202\202\211\305=\2034\306 \2062`\262`X\203@`\262\202F\262`\262\211\307=\204R\211\310=\203YT\262\202t\211\304=\203tb\210\311 \210`\262b\210\312y\210\311 \210`\262dV\203}d\262B\266\204)\207" [prefix-arg nil point-moving-unit command-execute line region mark match find beginning-of-line 1] 9 (#$ . 33809)])
#@77 Delete range specified by MOTION-COMMAND with ARG.

(fn MOTION-COMMAND ARG)
(defalias 'vi-delete-op #[514 "\300\"\211@
A\301U?\205@\302!\262
\211\204!\303\"\210\202?\211\304Y\2038\211\305X\2038\306
\227\307$\210\202?\310
\307$\210\307\207" [vi-effective-range nil vi-prefix-char-value kill-region 65 90 append-to-register t copy-to-register] 11 (#$ . 34447)])
#@89 Yank (in vi sense) range specified by MOTION-COMMAND with ARG.

(fn MOTION-COMMAND ARG)
(defalias 'vi-yank-op #[514 "\300\"\211@
A\301U?\205@\302!\262
\211\204!\303\"\210\202?\211\304Y\2038\211\305X\2038\306
\227\301$\210\202?\307
\301$\210\310\207" [vi-effective-range nil vi-prefix-char-value copy-region-as-kill 65 90 append-to-register copy-to-register t] 11 (#$ . 34830)])
#@54 Yank (in vi sense) lines (= `yy' command).

(fn ARG)
(defalias 'vi-yank-line #[257 "\300
!S\301!B\262
\302\303\"\205\304\302\303#\207" [vi-prefix-numeric-value vi-prefix-char-value vi-yank-op next-line vi-set-last-change-command] 5 (#$ . 35231) "*P"])
#@131 See if STRING ends with a newline char.
Used in checking whether the yanked text should be put back as lines or not.

(fn STRING)
(defalias 'vi-string-end-with-nl-p #[257 "\211
GSH\300U\207" [10] 3 (#$ . 35495)])
#@236 Put yanked (in vi sense) text back before/above cursor.
If a numeric prefix value (currently it should be >1) is given, put back
text as lines.  If the optional after-p is given, put after/below the cursor.

(fn ARG &optional AFTER-P)
(defalias 'vi-put-before #[513 "\301!\302
\203
\303W\204
\304V\203\305!\204\306\307\"\207
\204&\303\262
\303Y\203>
\304X\203>\310\311\312ZS\313\"\202O\305!;\203K\305!\202O\306\314\"\262
\315
!\203j\203d\316y\210\317 \210\202q\317 \210\202q\203q\316u\210\320 \210\211c\210\321 \210\322\323#\207" [this-command vi-prefix-char-value nil 49 57 get-register error "Nothing in register %c" yank current-kill 48 do-not-rotate "Register %c is not containing text string" vi-string-end-with-nl-p 1 beginning-of-line push-mark exchange-point-and-mark vi-set-last-change-command vi-put-before] 8 (#$ . 35715) "P"])
#@66 Put yanked (in vi sense) text back after/below cursor.

(fn ARG)
(defalias 'vi-put-after #[257 "\300
\301\"\207" [vi-put-before t] 4 (#$ . 36592) "P"])
#@278 Perform shell command (as filter).
Performs command on range specified by MOTION-COMMAND
with ARG. If SHELL-COMMAND is not given, ask for one from minibuffer.
If char argument is given, it directs the output to a *temp* buffer.

(fn MOTION-COMMAND ARG &optional SHELL-COMMAND)
(defalias 'vi-shell-op #[770 "\301\"\211@
A

U?\205-\204\302\303\304\"\262\305\306	!?\306\n!?%\210\307\207" [vi-last-shell-command vi-effective-range read-string "!" nil shell-command-on-region vi-prefix-char-value t] 13 (#$ . 36751)])
#@234 Perform shift command on range specified by MOTION-COMMAND with ARG for
AMOUNT on each line.  Negative amount means shift left.
SPECIAL FEATURE: char argument can be used to specify shift amount(1-9).

(fn MOTION-COMMAND ARG AMOUNT)
(defalias 'vi-shift-op #[771 "\300\"\211@
A

U?\2053\301!\203+\302V\203#\301!\303Z\202)\303\301!Z\262\304#\210\305\207" [vi-effective-range vi-prefix-char-value 0 48 indent-rigidly t] 10 (#$ . 37286)])
#@96 Perform indent command on range specified by MOTION-COMMAND with ARG.

(fn MOTION-COMMAND ARG)
(defalias 'vi-indent-op #[514 "\300\"\211@
A

U?\205\301\302#\210\303\207" [vi-effective-range indent-region nil t] 9 (#$ . 37743)])
#@81 Narrow to region specified by MOTION-COMMAND with ARG.

(fn MOTION-COMMAND ARG)
(defalias 'vi-narrow-op #[514 "\300\"\211@
A

U?\205

}\207" [vi-effective-range] 7 (#$ . 37983)])
#@81 Return contents of vi mark register named CHAR, or nil if undefined.

(fn CHAR)
(defalias 'vi-get-mark #[257 "\211\236A\207" [vi-mark-alist] 3 (#$ . 38172)])
#@118 Set contents of vi mark register named CHAR to current point.
'@' is the special anonymous mark register.

(fn CHAR)
(defalias 'vi-set-mark #[257 "\301
\302\"\203\303\304!\207\211\236\211\203\211A`\304\223\207
\305 B\262
\211B\211\207" [vi-mark-alist char-equal 64 set-mark-command nil point-marker] 5 (#$ . 38338) "c"])
#@52 Locate the matching paren.  It's a hack right now.
(defalias 'vi-find-matching-paren #[0 "\300\301!\203
\302\303!\210\304u\207\300\305!\203\303u\210\306\303!\207\307 \207" [looking-at "[[({]" forward-sexp 1 -1 "[])}]" backward-sexp ding] 2 (#$ . 38672) nil])
#@51 Backward COUNT blank-delimited words.

(fn COUNT)
(defalias 'vi-backward-blank-delimited-word #[257 "\300\301\302\303$\205o?\205\304u\207" [re-search-backward "[ 	\n`][^ 	\n`]+" nil t 1] 6 (#$ . 38940) "p"])
#@50 Forward COUNT blank-delimited words.

(fn COUNT)
(defalias 'vi-forward-blank-delimited-word #[257 "\300\301\302\303$\205m?\205\304u\207" [re-search-forward "[^ 	\n]*[ 	\n]+[^ 	\n]" nil t -1] 6 (#$ . 39159) "p"])
#@70 Forward to the end of the COUNT'th blank-delimited word.

(fn COUNT)
(defalias 'vi-end-of-blank-delimited-word #[257 "\300\301\302\303$\205m?\205\304u\207" [re-search-forward "[^ 	\n']+[ 	\n']" nil t -2] 6 (#$ . 39382) "p"])
#@69 To window home or arg'th line from the top of the window.

(fn ARG)
(defalias 'vi-home-window-line #[257 "\300
S!\210\301 \207" [move-to-window-line back-to-indentation] 3 (#$ . 39618) "p"])
#@77 To window last line or arg'th line from the bottom of the window.

(fn ARG)
(defalias 'vi-last-window-line #[257 "\300
[!\210\301 \207" [move-to-window-line back-to-indentation] 3 (#$ . 39815) "p"])
#@35 To the middle line of the window.
(defalias 'vi-middle-window-line #[0 "\300\301!\210\302 \207" [move-to-window-line nil back-to-indentation] 2 (#$ . 40020) nil])
#@69 Stop at the beginning of the COUNT'th words from point.

(fn COUNT)
(defalias 'vi-forward-word #[257 "\300\301\302\303$\203\303\207\304 \207" [re-search-forward "\\w*\\W+\\<" nil t vi-ding] 6 (#$ . 40189) "p"])
#@69 Set (FUN . ARGS) as the `last-change-command'.

(fn FUN &rest ARGS)
(defalias 'vi-set-last-change-command #[385 "

B\211\207" [vi-last-change-command] 4 (#$ . 40409)])
#@161 Redo last change command COUNT times.  If the optional COMMAND is given,
it is used instead of the current `last-change-command'.

(fn COUNT &optional COMMAND)
(defalias 'vi-redo-last-change-command #[513 "\211\204\262
\211\204\301\302!\207
\303V\205#\304
@A\"\210
S\262\202\207" [vi-last-change-command message "No last change command available." 0 apply] 5 (#$ . 40585) "p"])
#@50 Kill COUNT chars from current point.

(fn COUNT)
(defalias 'vi-kill-char #[257 "\300
\301\"\210\302\300\301#\207" [delete-char t vi-set-last-change-command] 5 (#$ . 40979) "*p"])
#@248 Transpose objects.
The following char specifies unit of objects to be
transposed -- "c" for chars, "l" for lines, "w" for words, "s" for
 sexp, "p" for paragraph.
For the use of the prefix-arg, refer to individual functions called.

(fn ARG UNIT)
(defalias 'vi-transpose-objects #[514 "\300
\301\"\203\302\303!\210\304 \262
\305\306#\210\300
\307\"\203 \310!\207\300
\311\"\203-\312\313!!\207\300
\314\"\203:\315\313!!\207\300
\316\"\203G\317\313!!\207\300
\320\"\203T\321\313!!\207\306\301\"\207" [char-equal 63 message "Transpose: c(har), l(ine), p(aragraph), s(-exp), w(ord)," read-char vi-set-last-change-command vi-transpose-objects 99 transpose-chars 108 transpose-lines vi-prefix-numeric-value 112 transpose-paragraphs 115 transpose-sexps 119 transpose-words] 6 (#$ . 41166) "*P\nc"])
#@64 Query replace, use regexp version if ARG is non-nil.

(fn ARG)
(defalias 'vi-query-replace #[257 "\211\203\300\202	\301\302
\303\"\207" [query-replace-regexp query-replace call-interactively nil] 5 (#$ . 41979) "*P"])
#@66 Replace strings, use regexp version if ARG is non-nil.

(fn ARG)
(defalias 'vi-replace #[257 "\211\203\300\202	\301\302
\303\"\207" [replace-regexp replace-string call-interactively nil] 5 (#$ . 42206) "*P"])
#@78 Move current line to the top/center/bottom of the window.

(fn ARG POSITION)
(defalias 'vi-adjust-window #[514 "\300
\301\"\203\302\303!\207\300
\304\"\203\302\305!\207\300
\306\"\203$\302\307 \310\245!\207\311\312!\210\313 \262
\314\"\207" [char-equal 13 recenter 0 45 -1 46 window-height 2 message "Move current line to: \\r(top) -(bottom) .(middle)" read-char vi-adjust-window] 5 (#$ . 42424) "p\nc"])
#@51 Go to given column of the current line.

(fn COL)
(defalias 'vi-goto-column #[257 "`\300 \210
\301V\203l\203\302\262\202\301u\210
S\262\202
\301U\203&\303\207\211b\210\304 \207" [beginning-of-line 1 0 t ding] 4 (#$ . 42842) "p"])
#@219 Give name to the last change command or just defined kbd macro.
If prefix ARG is given, name last macro, otherwise name last change command.
The following CHAR will be the name for the command or macro.

(fn ARG CHAR)
(defalias 'vi-name-last-change-or-macro #[514 "
\203\f\301\302\303!!!\207@\304=\203)A\211@
A@{\3058\3068\307\310$\266\302\303!!M\207" [vi-last-change-command name-last-kbd-macro intern char-to-string vi-first-redo-insertion 2 3 vi-set-last-change-command vi-more-redo-insertion] 11 (#$ . 43090) "P\nc"])
#@97 Execute COUNT times the keyboard macro definition named by the following CHAR.

(fn COUNT CHAR)
(defalias 'vi-call-named-change-or-macro #[514 "\300\301!!K;\203\302\300\301!!\"\207\303\300\301!!K\"\207" [intern char-to-string execute-kbd-macro vi-redo-last-change-command] 7 (#$ . 43631) "p\nc"])
#@52 Change the case of the char after point.

(fn ARG)
(defalias 'vi-change-case #[257 "\30024\301\302!\203\303``\\\"\210\202,\301\304!\203$\305``\\\"\210\202,\306 \210\307\300\310\"\210\311\312\"\210\211u0\207" [exit looking-at "[a-z]" upcase-region "[A-Z]" downcase-region ding throw nil vi-set-last-change-command vi-change-case] 5 (#$ . 43941) "*p"])
#@91 Inquire status info. The next CHAR will specify the particular info requested.

(fn CHAR)
(defalias 'vi-ask-for-info #[257 "\300
\301\"\203\n\302 \207\300
\303\"\203\304 \207\300
\305\"\203\306 \207\307\310!\210\311 \262
\312
!\207" [char-equal 108 what-line 99 what-cursor-position 112 what-page message "Ask for: l(ine number), c(ursor position), p(age number)" read-char vi-ask-for-info] 4 (#$ . 44307) "c"])
#@182 Mark region appropriately.  The next char REGION is d(efun),s(-exp),b(uffer),
p(aragraph), P(age), f(unction in C/Pascal etc.), w(ord), e(nd of sentence),
l(ines).

(fn ARG REGION)
(defalias 'vi-mark-region #[514 "\300
\301\"\203\n\302 \207\300
\303\"\203\304!\207\300
\305\"\203\306 \207\300
\307\"\203)\310 \207\300
\311\"\2034\312!\207\300
\313\"\203>\314 \207\300
\315\"\203I\316!\207\300
\317\"\203T\320!\207\300
\321\"\203_\322!\207\323\324!\210\325 \262
\326\"\207" [char-equal 100 mark-defun 115 mark-sexp 98 mark-whole-buffer 112 mark-paragraph 80 mark-page 102 c-mark-function 119 mark-word 101 mark-end-of-sentence 108 vi-mark-lines message "Mark: d(efun),s(-exp),b(uf),p(arag),P(age),f(unct),w(ord),e(os),l(ines)" read-char vi-mark-region] 5 (#$ . 44731) "p\nc"])
#@66 Mark NUM of lines from current line as current region.

(fn NUM)
(defalias 'vi-mark-lines #[257 "\300\301!\210\302 \210\211\207" [beginning-of-line 1 push-mark] 3 (#$ . 45531)])
#@114 Verify spelling for the objects specified by char UNIT : [b(uffer),
r(egion), s(tring), w(ord) ].

(fn ARG UNIT)
(defalias 'vi-verify-spelling #[514 "
\301
\302\"\203
\303\304!\207\301
\305\"\203\303\306!\207\301
\307\"\203#\303\310!\207\301
\311\"\203.\303\312!\207\313\314!\210\315 \262
\316\"\207" [prefix-arg char-equal 98 call-interactively spell-buffer 114 spell-region 115 spell-string 119 spell-word message "Spell check: b(uffer), r(egion), s(tring), w(ord)" read-char vi-verify-spelling] 5 (#$ . 45717) "P\nc"])
#@79 This is a hack for accessing mode specific C-c commands in vi-mode.

(fn ARG)
(defalias 'vi-do-old-mode-C-c-command #[257 "\304\305\306\307 !P\"\3102$\211\204\311 \210\312\202#	
\313
\312\"\210)\3120\2050\314 \210
\313
\312\"\207" [vi-mode-old-local-map vi-mode-old-case-fold case-fold-search prefix-arg lookup-key "" char-to-string read-char exit-vi-mode ding nil command-execute vi-back-to-old-mode] 6 (#$ . 46253) "P"])
#@137 Quote ARG words from the word point is on with pattern specified by CHAR.
Currently, CHAR could be [,{,(,",',`,<,*, etc.

(fn ARG CHAR)
(defalias 'vi-quote-words #[514 "\300\301\302!\"\204\303\304!\210\305 \262
\202\306\307#\210\310\311!\204#\312v\210\211c\210\313
\314\"\2033\315\262
\202d\313
\316\"\203@\317\262
\202d\313
\320\"\203M\321\262
\202d\313
\322\"\203Z\323\262
\202d\313
\324\"\203d\325\262
\326!\210\327u\210\211c\207" [string-match "[[({<\"'`*]" char-to-string message "Enter any of [,{,(,<,\",',`,* as quoting character." read-char vi-set-last-change-command vi-quote-words looking-at "\\<" -1 char-equal 91 93 123 125 60 62 40 41 96 39 vi-end-of-word 1] 6 (#$ . 46693) "*p\nc"])
#@130 Locate definition in current file for the name before the point.
It assumes a `(def..' always starts at the beginning of a line.
(defalias 'vi-locate-def #[0 "\300\212\301\302!\210\303\300w\210`\304\302!\210\300u\210\303\300x\210`{\262
)\305\300!\210eb\210\306\307P\300\310#?\2058\311 \210\312\313\"\210\305\310!\207" [nil vi-backward-blank-delimited-word 1 "^a-zA-Z" vi-end-of-blank-delimited-word set-mark-command re-search-forward "^(def[unvarconst ]*" t ding message "No definition for \"%s\" in current file."] 5 (#$ . 47415) nil])
#@93 Insert a newline and leave point before it.
With ARG, inserts that many newlines.

(fn ARG)
(defalias 'vi-split-open-line #[257 "\300\301\302D\303#\207" [vi-goto-insert-state 1 #[257 "n\205o?\211\203
\301u\210
\302V\203&\212\303c\210\203c\210)
S\262\202
\211\205,\304u\207" [fill-prefix -1 0 10 1] 4 "\n\n(fn ARG)"] t] 5 (#$ . 47961) "*p"])
(provide 'vi)