gnu1987/emacs18.41/lisp/vip.elc

(defvar emacs-local-map nil "\
Local map used in emacs mode. (buffer specific)")

(defvar insert-local-map nil "\
Local map used in insert command mode. (buffer specific)")

(make-variable-buffer-local (quote emacs-local-map))

(make-variable-buffer-local (quote insert-local-map))

(defvar insert-point nil "\
Remember insert point as a marker. (buffer specific)")

(set-default (quote insert-point) (make-marker))

(make-variable-buffer-local (quote insert-point))

(defvar com-point nil "\
Remember com point as a marker. (buffer specific)")

(set-default (quote com-point) (make-marker))

(make-variable-buffer-local (quote com-point))

(defvar current-mode nil "\
Current mode.  One of emacs-mode, vi-mode, insert-mode.")

(make-variable-buffer-local (quote current-mode))

(set-default (quote current-mode) (quote emacs-mode))

(defvar current-major-mode nil "\
current-major-mode is the major-mode vi considers it is now.
(buffer specific)")

(make-variable-buffer-local (quote current-major-mode))

(defvar vi-last-shell-com nil "\
last shell command executed by ! command")

(defvar use-register nil "\
name of register to store deleted or yanked strings.")

(defvar d-com nil "\
If non-nil, it's value is a list (M-COM VAL COM), and is used to
re-execute last destrcutive command")

(defconst shift-width 8 "\
*The number of colums shifted by > and < command.")

(defconst re-replace nil "\
*If t then do regexp replace, if nil then do string replace.")

(defvar d-char nil "\
The character remenbered by the vi \"r\" command")

(defvar f-char nil "\
for use by \";\" command")

(defvar F-char nil "\
for use by \".\" command")

(defvar f-forward nil "\
for use by \";\" command")

(defvar f-offset nil "\
for use by \";\" command")

(defconst vi-search-wrap-around t "\
*if t, search wraps around")

(defconst re-search nil "\
*if t, search is reg-exp search, otherwise vanilla search.")

(defvar s-string nil "\
last search string")

(defvar s-forward nil "\
if t, search is forward.")

(defconst vi-case-fold-search nil "\
*if t, search ignores cases.")

(defconst re-query-replace nil "\
*If t then do regexp replace, if nil then do string replace.")

(defconst vi-open-with-indent nil "\
*if t, indent when open a new line.")

(defconst help-in-insert-mode nil "\
*if t then C-h is bound to help-command in insert mode, if nil then it is
bound to delete-backward-char.")

(defvar vi-quote-string "> " "\
string inserted at the beginning of region")

(setq tags-file-name "TAGS")

(global-set-key "" (quote change-mode-to-vi))

(defmacro loop (count body) "(COUNT BODY) Execute BODY COUNT times." (byte-code "ÂÀDCÃÄÀÅE	ÆÀÇÀDEFE‡" [count body let while > 0 setq 1-] 9))

(defun push-mark-silent (&optional location) "\
Set mark at location (point, by default) and push old mark on mark ring.
No message." (byte-code "Ä ?ƒ
À‚+ÅÆ !	B‰ˆ	G
V…+ÇÈ
	\"@À\"ˆÉÈ
S	\"À\"ˆÊ†2`!‡" [nil mark-ring mark-ring-max location mark copy-marker mark-marker move-marker nthcdr setcdr set-mark] 9))

(defun vi-goto-col (arg) "\
(ARG)  Go to ARG's column." (interactive "P") (byte-code "ĈÅ	!Æ	!ŠÇ ˆiTV…ÈÉ!)ˆ
…\"Ê`\"ˆË ˆÌS!ˆ
…4ÍÎ
#*‡" [val arg com com-point nil p-val getcom end-of-line error "" move-marker beginning-of-line forward-char execute-com vi-goto-col] 11))

(defun refresh-mode-line nil "\
Redraw mode line." (byte-code "ÀÁ !‡" [set-buffer-modified-p buffer-modified-p] 3))

(defun vi-copy-keymap (map) (byte-code "?ƒ
Á ‚
Â!‡" [map make-sparse-keymap copy-keymap] 3))

(defun change-mode (new-mode) "\
(NEW-MODE)  Change mode to NEW-MODE.  NEW-MODE is either emacs-mode,
vi-mode, or insert-mode." (byte-code "	=†ŠÇ=ƒ0	È=ƒÉ`
\"ˆÊ ‚%Ë ÌË !‰ˆÍÎ!ˆÏ
!‚ƒÈ=ƒvÐ
`\"ˆ	Ñ=…JË ÌË !‰ˆÍÒ!ˆÏ!ˆÓÔÕ#ˆÓÖ×#ˆÓ؃kÙ‚lÚ#ˆÓÛÜ#‚ƒÑ=…ƒÍÝ!ˆÏ!ˆ‰ˆÞ ‡" [new-mode current-mode insert-point emacs-local-map insert-local-map vi-command-mode-map help-in-insert-mode vi-mode insert-mode vi-copy-region-as-kill repeat-insert-command current-local-map vi-copy-keymap change-mode-line "Vi:   " use-local-map move-marker emacs-mode "Insert" define-key "" change-mode-to-vi "" vi-ESC "" help-command delete-backward-char "" delete-backward-word "Emacs:" refresh-mode-line] 21))

(defun vi-copy-region-as-kill (beg end) "\
(BEG END)  If BEG and END do not belong to the same buffer, it copies
empty region." (byte-code "ÀÁÂ�‡" [nil (byte-code "Â	\"‡" [beg end copy-region-as-kill] 3) ((error (byte-code "Á\"‡" [beg copy-region-as-kill] 3)))] 3))

(defun change-mode-line (string) "\
Assuming that the mode line format contains the string \"Emacs:\", this
function replaces the string by \"Vi:   \" etc." (byte-code "	ÂPC‰‡" [mode-line-buffer-identification string " %17b"] 2))

(defun vip-mode nil "\
Turn on VIP emulation of VI." (interactive) (byte-code "ÀˆÁ ‡" [nil change-mode-to-vi] 2))

(defun change-mode-to-vi nil "\
()  Change mode to vi." (interactive) (byte-code "ÀˆÁÂ!‡" [nil change-mode vi-mode] 2))

(defun change-mode-to-insert nil "\
()  Change mode to insert." (interactive) (byte-code "ÀˆÁÂ!‡" [nil change-mode insert-mode] 2))

(defun change-mode-to-emacs nil "\
()  Change mode to emacs." (interactive) (byte-code "ÀˆÁÂ!‡" [nil change-mode emacs-mode] 2))

(defun get-editor-command (l-map g-map &optional str) "\
(L-MAP G-MAP STR)  Read characters from keyboard until an editor command
is formed, using local keymap L-MAP and global keymap G-MAP.  If the
command is a self-insert-command, the character just read is returned
instead.  Optional string STR is used as initial input string." (byte-code "ÇÇÇ?†ÈÉ\"ƒr‚Ê!‰ˆ‰ˆË
\"‰ˆ	?ƒ[Ë\"‰ˆ
?ƒ=Ç‚XÌ
!ƒMÍÇ
Î!#‚X
Ï=ƒW‚X
‚�Ì	!ƒ’Ë\"‰ˆ
?ƒxÍ	ÇÎ!#‚�Ì
!ƒˆÍ	
Î!#‚�Í	ÇÎ!#‚�	Ï=ƒœ‚�	+‡" [char l-bind g-bind str last-command-char l-map g-map nil string= "" string-to-char binding-of keymapp get-editor-command string-tail self-insert-command] 19))

(defun binding-of (char map) "\
(CHAR MAP)  Return key-binding of CHAR under keymap MAP.  It is nil if
the binding is void, or a command, or a keymap" (byte-code "	<ƒ
Æ
	\"A‚	
H?ƒÂBÇ!ƒ.9ƒ*K‚+‚BK
?†9Ç
!ƒ@
‚A))‡" [val map char nil t fun assq keymapp] 4))

(defun escape-to-emacs (arg &optional char) "\
(ARG &optional CHAR)  Escape to emacs mode and execute one emacs
command and then return to vi mode.  ARG is used as the prefix value
for the executed command.  If CHAR is given it becomes the first
character of the command." (interactive "P") (byte-code "ȈÈpÃ…‰ˆ‰ˆ
†
ÌY…]ȉˆÍ	
\"‰ˆÎ!ƒTÏ!ÌV…PÐÑ!!ˆS‰ˆ‚9)‚YÒ\"ˆ‚ˆÈ‰+‡" [com buff first t char unread-command-char prefix-arg arg nil emacs-local-map global-map count 0 get-editor-command numberp p-val insert-string char-to-string command-execute] 9))

(defun message-conditions (conditions) "\
Print conditions as a message." (byte-code "	@	A
?ƒÃÄ\"‚ÃÅÆ
!#ˆÇ *‡" [case conditions msg message "%s" "%s %s" prin1-to-string ding] 6))

(defun vi-ESC (arg) "\
" (interactive "P") (byte-code "ÁˆÂÃ\"‡" [arg nil escape-to-emacs 27] 3))

(defun vi-ctl-c (arg) "\
" (interactive "P") (byte-code "ÁˆÂÃ\"‡" [arg nil escape-to-emacs 3] 3))

(defun vi-ctl-x (arg) "\
" (interactive "P") (byte-code "ÁˆÂÃ\"‡" [arg nil escape-to-emacs 24] 3))

(defun vi-ctl-h (arg) "\
" (interactive "P") (byte-code "ÁˆÂÃ\"‡" [arg nil escape-to-emacs 8] 3))

(defun vi-prefix-arg-value (char value com) "\
(CHAR VALUE COM)  Compute numeric prefix arg value.  Invoked by
CHAR.  VALUE is the value obtained so far, and COM is the command part
obtained so far." (byte-code "ÅY…	ÆX…(ÇÈ	!ƒ	‚ÉÊ\"ÅZ\\‰ˆr‰ˆ‚ˆ	‰ˆ…6
B‰ˆËU…HÌ
!ˆr‰ˆ‚7ˆ‰‡" [char value prefix-arg com unread-command-char 48 57 * numberp 0 10 85 describe-arg] 6))

(defun vi-prefix-arg-com (char value com) "\
Vi operator as prefix argument." (byte-code "Á…E
ÊU†E
ËU†E
ÌU†E
ÍU†E
ÎU†E
ÏU†E
ÐU†E
ÑU†E
ÒU†E
ÓU†E
ÔU…ûƒh
ÑU†U
ÔU…[ÕÖ!ˆ
B‰ˆÄ‰‚÷
ÍU†q
ÐUƒ‚
‰ˆr‰ˆÄ‰‚÷
ÑUƒ˜×r\\‰ˆr‰ˆÄ‰‚÷
ÎU†¡
ÏUƒ¾
‰ˆr‰ˆ
U…·
B‰ˆÄ‰‚÷
ÔUƒðrØ
X…Ï
ÙX†ÛÚ
X…Û
ÛXƒå
‰‚èÕÖ!ˆr‰)‚÷
‰ˆr‰ˆ‚)ˆÜ!ƒ%
B‰ˆ
ÝU…
Þ!ˆr‰ˆ‚
ˆ
‰	‚ï
@ÒU†0
@ÓUƒ[
@AB‰ˆ
ÒUƒN
ß!‚R
à!ˆÄ‰*‚ï
?ƒe
á‚g
‰ˆÄ‰ˆâã\"ƒ€
äåB!‚ï
âæ\"ƒ�
äçB!‚ï
âè\"ƒœ
é ‚ï
âê\"ƒ¬
äëB!‚ï
âì\"ƒ¼
äÎB!‚ï
âí\"ƒÌ
äÏB!‚ï
âî\"ƒÜ
äÍB!‚ï
âï\"ƒì
äÐB!‚ï
ÕÖ!‡" [cont t char com nil reg use-register prefix-arg value unread-command-char 99 100 121 33 60 62 61 35 114 82 34 error "" 128 65 122 49 57 atom 85 describe-arg vi-region vi-Region 1 equal (99 . 99) vi-line 67 (100 . 100) 68 (100 . 121) vi-yank-defun (121 . 121) 89 (60 . 60) (62 . 62) (33 . 33) (61 . 61)] 24))

(defun describe-arg (arg) (byte-code "ÃÃÄ
!Å
!‰ˆ?ƒ%	?ƒÆÇ!‚\"ÆÈ	\"‚6	?ƒ1ÆÉ\"‚6ÆÊ	#*‡" [val com arg nil P-val getcom message "Value is nil, and commmand is nil." "Value is nil, and command is %c." "Value is %d, and command is nil." "Value is %d, and command is %c."] 9))

(defun vi-digit-argument (arg) "\
Begin numeric argument for the next command." (interactive "P") (byte-code "ÁˆÃÁ
:ƒ
A‚Á#‡" [last-command-char nil arg vi-prefix-arg-value] 4))

(defun vi-command-argument (arg) (interactive "P") (byte-code "ÀˆÁÂÃ�‡" [nil conditions (byte-code "Ä	?ƒ‚\"	:ƒ	@‚\"Å	!ƒ	‚\"ÆÇ!	?ƒ+‚B	:ƒ5	A‚BÅ	!ƒ?‚BÆÇ!#‡" [last-command-char arg nil t vi-prefix-arg-com numberp error "strange arg"] 8) ((quit (byte-code "Á‰ˆÂÃÁ\"‡" [use-register nil signal quit] 3)))] 3))

(defun p-val (arg) "\
(ARG)  Get value part of prefix-argument ARG." (byte-code "?ƒ	‚:ƒ@?ƒ‚@‚‡" [arg t 1] 1))

(defun P-val (arg) "\
(ARG)  Get value part of prefix-argument ARG." (byte-code ":ƒ
@‚‡" [arg t] 1))

(defun getcom (arg) "\
(ARG)  Get com part of prefix-argument ARG." (byte-code "?ƒ	Á‚:ƒA‚Á‡" [arg nil t] 1))

(defun getCom (arg) "\
(ARG)  Get com part of prefix-argument ARG and modify it." (byte-code "Ã	!ÄÅ\"ƒÆ‚&ÄÇ\"ƒÈ‚&ÄÉ\"ƒ%Ê‚&)‡" [com arg t getcom equal 99 67 100 68 121 89] 6))

(defun vi-append-to-register (reg start end) "\
Append region to text in register REG.
START and END are buffer positions indicating what to append." (byte-code "ÃÄ!†	ÅÆ	
\"P\"‡" [reg start end set-register get-register "" buffer-substring] 7))

(defun execute-com (m-com val com) "\
(M-COM VAL COM)  Execute command COM. The list (M-COM VAL COM) is set
to d-com for later use by vi-repeat" (byte-code "	
…µ
ÍUƒÎ`\"‚µ
Í[Uƒ!Ï`\"‚µ
ÐU†+
Ð[Uƒ‘ŠÑ!ˆÒÓ `\"ˆ	…uÔ	X…F	ÕXƒSÖ	Ó `Ä$‚q×	X…\\	ØXƒjÙ	Ú\\Ó `#‚qĉˆÛÜ!ˆÄ‰ˆÝÓ `\")ˆÞß!ˆ
ÐUƒŒà ‚Žá ‚µ
âUƒî	…ÑÔ	X…¤	ÕXƒ°Ö	`Ä$‚Í×	X…¹	ØXƒÆÙ	Ú\\`#‚ÍĉˆÛÜ!ˆÄ‰ˆã=ƒÝä‚Þĉˆä`\"ˆã‰‚µ
åUƒd
ŠÑ!ˆÒÓ `\"ˆ	…;
Ô	X…
	ÕXƒ
Ö	Ó `Ä$‚7
×	X…\"
	ØXƒ0
Ù	Ú\\Ó `#‚7
ĉˆÛÜ!ˆÄ‰ˆæ=ƒG
ä‚H
ĉˆäÓ `\"ˆç=…]
æ‰)ˆè ‚µ
éUƒ´
	…¤
Ô	X…w
	ÕXƒƒ
Ö	`Ä$‚ 
×	X…Œ
	ØXƒ™
Ù	Ú\\`#‚ 
ĉˆÛÜ!ˆÄ‰ˆÄ‰ˆê`\"ˆb‚µ
ëUƒŠÑ!ˆÒÓ `\"ˆ	…
Ô	X…Ò
	ÕXƒß
Ö	Ó `Ä$‚ý
×	X…è
	ØXƒö
Ù	Ú\\Ó `#‚ý
ĉˆÛÜ!ˆÄ‰ˆÄ‰ˆêÓ `\")ˆb‚µ
ìU†
ì[UƒFŠÑ!ˆÒÓ `\"ˆíÓ `
ìUƒ>îï!‰	‚@	Å$)‚µ
ðUƒkŠÑ!ˆÒÓ `\"ˆÓ `V…`ñ ˆòÓ `Ä#)‚µ
óUƒ‹ŠÑ!ˆÒÓ `\"ˆôÓ `
[#)ˆb‚µ
õUƒªŠÑ!ˆÒÓ `\"ˆôÓ `
#)ˆb‚µ
öY…µ÷
öZ!ˆ
ÍU†É
ÐU†É
ìUƒÑ
[‚Ò
F‰)‡" [reg use-register com com-point nil t last-command this-command m-com vi-last-shell-com shift-width d-com val 99 vi-change vi-change-subr 67 set-mark enlarge-region mark 97 122 copy-to-register 65 90 vi-append-to-register 32 error "" delete-region open-line 1 change-mode-to-insert yank 100 d-command kill-region 68 D-command vi-line back-to-indentation 121 copy-region-as-kill 89 33 shell-command-on-region vi-read-string "!" 61 exchange-point-and-mark indent-region 60 indent-rigidly 62 128 special-prefix-com] 72))

(defun vi-repeat (arg) "\
(ARG)  Re-excute last destructive command.  d-com has the form
  (COM ARG CH REG), where COM is the command to be re-executed, ARG is the
argument for COM, CH is a flag for repeat, and REG is optional and if exists
is the name of the register for COM." (interactive "P") (byte-code "ȈÉ=ƒ
Ê ‚?
@Ë!
AA@Ì
8?…(
A@‰ˆ	?…1ÍÎ!ˆ‰ˆÏ	
B\",‡" [last-command m-com d-com val arg com reg use-register nil vi-undo vi-undo-more P-val 3 error "No previous command to repeat." funcall] 7))

(defun special-prefix-com (char) "\
This command is invoked interactively by the key sequence #<char>" (byte-code "ÂUƒÃ	`^	`]\"‚JÄUƒ\"Å	`^	`]\"‚JÆUƒ1Ç	!ˆÈ ‚JÉUƒ@Ç	!ˆÊ ‚JËU…JÌ	`\"‡" [char com-point 99 downcase-region 67 upcase-region 103 set-mark global-execute 113 quote-region 115 spell-region] 9))

(defun vi-undo nil "\
" (interactive) (byte-code "ÁˆÂÃ!ˆÄ ˆÅÆ!ˆÇ‰‡" [this-command nil message "undo!" undo-start undo-more 2 vi-undo] 5))

(defun vi-undo-more nil "\
" (byte-code "ÁÂ!ˆÃÄ!ˆÅ‰‡" [this-command message "undo more!" undo-more 1 vi-undo] 4))

(defun string-tail (str) (byte-code "?†	ÂÃ\"ƒÁ‚ÄÁO‡" [str nil string= "" 1] 4))

(defun vi-yank-defun nil (byte-code "À ˆÁ` \"‡" [mark-defun copy-region-as-kill mark] 5))

(defun enlarge-region (beg end) "\
(BEG END)  Enlarge region between BEG and END." (byte-code "	WƒbˆÂ	!‚	bˆÂ!ˆÃ ˆÄ ˆm?†#n?…)ÅÆ!ˆÃ ˆ	V…5Ä ‡" [beg end set-mark beginning-of-line exchange-point-and-mark next-line 1] 8))

(defun global-execute nil "\
Call last keyboad macro for each line in the region." (byte-code "`À V…	Á ˆÂ ˆÃ ˆ`À W…$ÄÅ!ˆÂ ˆÃ ˆ‚‡" [mark exchange-point-and-mark beginning-of-line call-last-kbd-macro forward-line 1] 10))

(defun quote-region nil "\
Quote region by inserting the user supplied string at the beginning of
each line in the region." (byte-code "ÂÃÄ\"!Å	Æ\"ƒ‚	)‰ˆÇ`È \"ˆ`È V…&É ˆÊ!ˆË ˆÌÍ!ˆ`È W…:n…KÊ!ˆË ˆÌÍ!ˆ‚2‡" [vi-quote-string str vi-read-string format "quote string (default \"%s\"): " string= "" enlarge-region mark exchange-point-and-mark insert-string beginning-of-line forward-line 1] 16))

(defun end-with-a-newline-p (string) "\
Check if the string ends with a newline." (byte-code "ÂÃ\"†		GSHÄU‡" [text string string= "" 10] 3))

(defun vi-read-string (prompt &optional init) (byte-code "Ã	!‰ˆÄ	ÅÆ#ˆÄ	ÇÈ#ˆÄ	ÉÊ#ˆËÌÍÎ�ˆ‰ˆ
)‡" [save-minibuffer-local-map minibuffer-local-map str copy-keymap define-key "" backward-char "" backward-word "" exit-minibuffer nil conditions (byte-code "Ã	
\"‰‡" [str prompt init read-string] 3) ((quit (byte-code "	‰ˆÃÄÂ\"‡" [minibuffer-local-map save-minibuffer-local-map nil signal quit] 3)))] 7))

(defun repeat-insert-command nil "\
()  This function is called when mode changes from insertion mode to
vi command mode.  It will repeat the insertion command if original insertion
command was invoked with argument > 1." (byte-code "	@	A@
…
ÄV…#
SÅE‰ˆÆÃ!ˆ
ÅE‰*‡" [i-com d-com val nil 1 114 vi-repeat] 4))

(defun vi-insert (arg) "\
" (interactive "P") (byte-code "ňÆ	!Ç	!ÈÉE‰ˆ
ƒ,ÊV…(Ë ˆS‰ˆ‚)‚.Ì *‡" [val arg com d-com count nil p-val getcom vi-insert 114 0 yank change-mode-to-insert] 6))

(defun vi-append (arg) "\
" (interactive "P") (byte-code "ňÆ	!Ç	!ÈÉE‰ˆl?…Ê ˆË
É\"ƒ7ÌV…3Í ˆS‰ˆ‚\")‚9Î *‡" [val arg com d-com count nil p-val getcom vi-append 114 forward-char equal 0 yank change-mode-to-insert] 8))

(defun vi-Append (arg) "\
" (interactive "P") (byte-code "ňÆ	!Ç	!ÈÉE‰ˆÊ ˆË
É\"ƒ2ÌV….Í ˆS‰ˆ‚)‚4Î *‡" [val arg com d-com count nil p-val getcom vi-Append 114 end-of-line equal 0 yank change-mode-to-insert] 8))

(defun vi-Insert (arg) "\
" (interactive "P") (byte-code "ňÆ	!Ç	!ÈÉE‰ˆÊ ˆË
É\"ƒ2ÌV….Í ˆS‰ˆ‚)‚4Î *‡" [val arg com d-com count nil p-val getcom vi-Insert 114 back-to-indentation equal 0 yank change-mode-to-insert] 8))

(defun vi-open-line (arg) "\
" (interactive "P") (byte-code "LjÈ	!É	!ÊËE‰ˆÌ Í
Ë\"ƒA
ÎV…=Ï ˆÐÑ!ˆ…1jˆÒ ˆ
S‰ˆ‚)‚RÏ ˆÐÑ!ˆ…OjˆÓ )*‡" [val arg com d-com col count vi-open-with-indent nil p-val getcom vi-open-line 114 current-indentation equal 0 end-of-line newline 1 yank change-mode-to-insert] 11))

(defun vi-Open-line (arg) "\
" (interactive "P") (byte-code "LjÈ	!É	!ÊËE‰ˆÌ Í
Ë\"ƒA
ÎV…=Ï ˆÐÑ!ˆ…1jˆÒ ˆ
S‰ˆ‚)‚RÏ ˆÐÑ!ˆ…OjˆÓ )*‡" [val arg com d-com col count vi-open-with-indent nil p-val getcom vi-Open-line 114 current-indentation equal 0 beginning-of-line open-line 1 yank change-mode-to-insert] 11))

(defun vi-ctl-open-line (arg) (interactive "P") (byte-code "ňÆ	!Ç	!ÈÉE‰ˆÊ
É\"ƒ3ËV…/ÌÍ!ˆÎ ˆS‰ˆ‚)‚9ÌÍ!ˆÏ *‡" [val arg com d-com count nil p-val getcom vi-ctl-open-line 114 equal 0 open-line 1 yank change-mode-to-insert] 8))

(defun vi-substitute (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!ŠÇ`!ˆÈ!ˆÉ
Ê\"ƒ\"ËÌ `\"‚'ÍÌ `\")ˆÎÊE‰*‡" [val arg com d-com nil p-val getcom set-mark forward-char equal 114 vi-change-subr mark vi-change vi-substitute] 12))

(defun vi-substitute-line (arg) (interactive "p") (byte-code "ÁˆÂÃB!‡" [arg nil vi-line 67] 3))

(defun vi-line (arg) (byte-code "	@	AÄ`\"ˆÅS!ˆÆÇ
#*‡" [val arg com com-point move-marker next-line execute-com vi-line] 6))

(defun vi-yank-line (arg) "\
(ARG)  Yank ARG lines (in vi's sense)" (interactive "P") (byte-code "ˆÃ	!ÄÅB!)‡" [val arg nil p-val vi-line 89] 4))

(defun vi-region (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!Ç`\"ˆÈ ˆÉÊ
#*‡" [val arg com com-point nil P-val getcom move-marker exchange-point-and-mark execute-com vi-region] 8))

(defun vi-Region (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!Ç`\"ˆÈ ˆÉÊ
#*‡" [val arg com com-point nil P-val getCom move-marker exchange-point-and-mark execute-com vi-Region] 8))

(defun vi-replace-char (arg) "\
(ARG)  Replace the following ARG chars by the character read." (interactive "P") (byte-code "ňÆ	!Ç	!ÈÉE‰ˆÊË
É\"ƒ‚r\"*‡" [val arg com d-com d-char nil p-val getcom vi-replace-char 114 vi-replace-char-subr equal] 6))

(defun vi-replace-char-subr (char arg) (byte-code "ÅÁ\"ˆ‰ˆÆVƒ‚[ÆV…'cˆS‰ˆ‚)ˆÇ!‡" [arg t d-char char count delete-char 0 backward-char] 4))

(defun vi-replace-string nil "\
()  Replace string.  If you supply null string as the string to be
replaced, the query replace mode will toggle between string replace
and regexp replace." (interactive) (byte-code "ˆÂÃ	ƒ
Ä‚Å!‰ˆÆÇ\"ƒ/	?‰ˆÈÉÊ	ƒ)Ë‚*Ì\"!‚H	ƒ?ÍÃÉÎ\"!\"‚HÏÃÉÐ\"!\")‡" [str re-replace nil vi-read-string "Replace regexp: " "Replace string: " string= "" message format "Replace mode changed to %s." "regexp replace" "string replace" replace-regexp "Replace regexp \"%s\" with: " replace-string "Replace \"%s\" with: "] 13))

(defun vi-forward-char (arg) "\
(ARG)  Move point right ARG characters (left if ARG negative).
On reaching end of buffer, stop and signal error." (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊ
#*‡" [val arg com com-point nil p-val getcom move-marker forward-char execute-com vi-forward-char] 8))

(defun vi-backward-char (arg) "\
(ARG)  Move point left ARG characters (right if ARG negative).
On reaching beginning of buffer, stop and signal error." (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊ
#*‡" [val arg com com-point nil p-val getcom move-marker backward-char execute-com vi-backward-char] 8))

(defun vi-forward-word (arg) "\
" (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆÉÊ!ˆ
…Q
ËU†)
Ë[U…3ÌÍ!ˆÈÍ!ˆ
ÎU†=
ÏU…KÌÍ!ˆÈÍ!ˆÉÐ!ˆÑÒ
#*‡" [val arg com com-point nil p-val getcom move-marker forward-word skip-chars-forward " 	
" 99 backward-word 1 100 121 " 	" execute-com vi-forward-word] 14))

(defun vi-end-of-word (arg) "\
move point to end of current word" (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ ˆÉ!ˆÊ ˆ
…)È ˆËÌ
#*‡" [val arg com com-point nil p-val getcom move-marker forward-char forward-word backward-char execute-com vi-end-of-word] 11))

(defun vi-backward-word (arg) "\
" (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊ
#*‡" [val arg com com-point nil p-val getcom move-marker backward-word execute-com vi-backward-word] 8))

(defun vi-forward-Word (arg) "\
" (interactive "P") (byte-code "ĈÆ	!Ç	!
…È`\"ˆÉÊÄÅ$ˆ
…P
ËU†(
Ë[U…2ÌÍ!ˆÎÍ!ˆ
ÏU†<
ÐU…JÌÍ!ˆÎÍ!ˆÑÒ!ˆÓÔ
#*‡" [val arg com com-point nil t p-val getcom move-marker re-search-forward "[^ 	
]*[ 	
]+" 99 backward-word 1 forward-word 100 121 skip-chars-forward " 	" execute-com vi-forward-Word] 13))

(defun vi-end-of-Word (arg) "\
" (interactive "P") (byte-code "ĈÆ	!Ç	!
…È`\"ˆÉ ˆÊËÄÅ$…!Ì ˆ
….É ˆÍÎ
#*‡" [val arg com com-point nil t p-val getcom move-marker forward-char re-search-forward "[^ 	
]+" backward-char execute-com vi-end-of-Word] 11))

(defun vi-backward-Word (arg) "\
" (interactive "P") (byte-code "ĈÆ	!Ç	!
…È`\"ˆÉÊÄÅ$ƒ!Ë ‚#ebˆ
…-ÌÍ
#*‡" [val arg com com-point nil t p-val getcom move-marker re-search-backward "[ 	
]+[^ 	
]+" forward-char execute-com vi-backward-Word] 9))

(defun vi-beginning-of-line (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊ
#*‡" [val arg com com-point nil p-val getcom move-marker beginning-of-line execute-com vi-beginning-of-line] 8))

(defun vi-bol-and-skip-white (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ ˆ
…ÉÊ
#*‡" [val arg com com-point nil p-val getcom move-marker back-to-indentation execute-com vi-bol-and-skip-white] 8))

(defun vi-goto-eol (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊ
#*‡" [val arg com com-point nil p-val getcom move-marker end-of-line execute-com vi-goto-eol] 8))

(defun vi-next-line (arg) (interactive "P") (byte-code "ňÆ	!Ç	!
…È`\"ˆÉ!ˆÉ‰ˆ
…$ÊË
#*‡" [val arg com com-point this-command nil p-val getCom move-marker next-line execute-com vi-next-line] 8))

(defun vi-next-line-at-bol (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆÉ ˆ
…#ÊË
#*‡" [val arg com com-point nil p-val getCom move-marker next-line back-to-indentation execute-com vi-next-line-at-bol] 9))

(defun vi-previous-line (arg) (interactive "P") (byte-code "ňÆ	!Ç	!
…È`\"ˆÉ[!ˆÊ‰ˆ
…%ËÌ
#*‡" [val arg com com-point this-command nil p-val getCom move-marker next-line previous-line execute-com vi-previous-line] 8))

(defun vi-previous-line-at-bol (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ[!ˆÉ ˆ
…$ÊË
#*‡" [val arg com com-point nil p-val getCom move-marker next-line back-to-indentation execute-com vi-previous-line] 9))

(defun vi-change-to-eol (arg) (interactive "P") (byte-code "ÁˆÂÃB!‡" [arg nil vi-goto-eol 99] 3))

(defun vi-kill-line (arg) (interactive "P") (byte-code "ÁˆÂÃB!‡" [arg nil vi-goto-eol 100] 3))

(defun vi-goto-line (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!Ç`\"ˆÈ`!ˆ?ƒdb‚$ebˆÉS!ˆÊ ˆ
…1ËÌ
#*‡" [val arg com com-point nil P-val getCom move-marker set-mark forward-line back-to-indentation execute-com vi-goto-line] 10))

(defun vi-find-char (arg char forward offset) "\
(ARG CHAR FORWARD OFFSET)  Find ARG's occurence of CHAR on the
current line.  If FORWARD then search is forward, otherwise backward.
OFFSET is used to adjust point after search." (byte-code "	ƒ‚
[ÅŠŒÆVƒ-Çlƒ ÈÉ!‚!`ÊË!ˆÌ ˆ`\"‚>Çnƒ8ÈÉ!‚9`Ì ˆ`\"ˆÆVƒKeTb‚MdbˆÍ`#‰ˆÆV…_
dU†kÆW…k
eU…qÈÉ!))ˆ
ƒ‡ÆVƒƒÎ‚„Æ‚ˆÏ\\b*‡" [arg forward point char offset nil 0 narrow-to-region error "" next-line 1 beginning-of-line scan-buffer -2 -1] 12))

(defun vi-find-char-forward (arg) "\
(ARG)  Find char on the line.  If called interactively read the char
to find from the terminal, and if called from vi-repeat, the char
last used is used.  This behaviour is controlled by the sign of prefix
numeric value." (interactive "P") (byte-code "LjÊ	!Ë	!ÌVƒrÅlj‚[‰ˆ
…)Í`\"ˆÎÊ	!ÌVƒ8‚:	ÅÇ$ˆ[‰ˆ
…T‰	ˆÏ ˆÐÑ
#*‡" [val arg com f-char f-forward t f-offset nil com-point F-char p-val getcom 0 move-marker vi-find-char forward-char execute-com vi-find-char-forward] 10))

(defun vi-goto-char-forward (arg) "\
" (interactive "P") (byte-code "ɈÊ	!Ë	!ÌVƒrÅʼn‚[‰ˆ
…)Í`\"ˆÎÊ	!ÌVƒ8‚:ÅÅ$ˆ[‰ˆ
…T‰ˆÏ ˆÐÑ
#*‡" [val arg com f-char f-forward t f-offset com-point F-char nil p-val getcom 0 move-marker vi-find-char forward-char execute-com vi-goto-char-forward] 10))

(defun vi-find-char-backward (arg) "\
" (interactive "P") (byte-code "ňÉ	!Ê	!ËVƒrÅʼn‚[‰ˆ
…)Ì`\"ˆÍÉ	!ËVƒ8‚:ÅÅ$ˆ[‰ˆ
…Q‰ˆÎÏ
#*‡" [val arg com f-char f-forward nil f-offset com-point F-char p-val getcom 0 move-marker vi-find-char execute-com vi-find-char-backward] 9))

(defun vi-goto-char-backward (arg) "\
" (interactive "P") (byte-code "ňÊ	!Ë	!ÌVƒrÅlj‚[‰ˆ
…)Í`\"ˆÎÊ	!ÌVƒ8‚:	ÅÇ$ˆ[‰ˆ
…Q‰	ˆÏÐ
#*‡" [val arg com f-char f-forward nil f-offset t com-point F-char p-val getcom 0 move-marker vi-find-char execute-com vi-goto-char-backward] 9))

(defun vi-semi-colon (arg) "\
" (interactive "P") (byte-code "LjÈ	!É	!
…Ê`\"ˆË
$ˆ
…+
…%Ì ˆÍÎ
#*‡" [val arg com com-point f-char f-forward f-offset nil p-val getcom move-marker vi-find-char forward-char execute-com vi-semi-colon] 9))

(defun vi-comma (arg) "\
" (interactive "P") (byte-code "LjÈ	!É	!
…Ê`\"ˆË
?$ˆ
…,
…&Ì ˆÍÎ
#*‡" [val arg com com-point f-char f-forward f-offset nil p-val getcom move-marker vi-find-char forward-char execute-com vi-comma] 9))

(defun vi-other-window (arg) (interactive "p") (byte-code "ˆÃ!ˆ	Ä=?†ÅÆp!Ç\"†È ‡" [arg current-mode nil other-window emacs-mode string= buffer-name " *Minibuf-1*" change-mode-to-vi] 5))

(defun vi-window-top (arg) "\
" (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈS!ˆ
…!ÉÊ
#*‡" [val arg com com-point nil p-val getCom move-marker move-to-window-line execute-com vi-window-top] 8))

(defun vi-window-middle (arg) "\
" (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈÉÊ SË\"S\\!ˆ
…(ÌÍ
#*‡" [val arg com com-point nil p-val getCom move-marker move-to-window-line / window-height 2 execute-com vi-window-middle] 10))

(defun vi-window-bottom (arg) "\
" (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ[!ˆ
…!ÉÊ
#*‡" [val arg com com-point nil p-val getCom move-marker move-to-window-line execute-com vi-window-bottom] 8))

(defun vi-line-to-top (arg) "\
" (interactive "p") (byte-code "ÁˆÂS!‡" [arg nil recenter] 2))

(defun vi-line-to-middle (arg) "\
" (interactive "p") (byte-code "ÁˆÂSÃÄ SÅ\"\\!‡" [arg nil recenter / window-height 2] 6))

(defun vi-line-to-bottom (arg) "\
" (interactive "p") (byte-code "ÁˆÂà TZ!‡" [arg nil recenter window-height] 4))

(defun vi-paren-match (arg) "\
(ARG)  Go to the matching parenthesis." (interactive "P") (byte-code "ÈÅ	!ÆÇ!ƒ*…È
`\"ˆÉÊ!ˆƒ%ËÌÃ#‚'Í ‚OÆÎ!ƒLÏ ˆ…;È
`\"ˆÐÊ!ˆ…IËÌÃ#‚OÑÒ!)‡" [com arg com-point nil t getcom looking-at "[([{]" move-marker forward-sexp 1 execute-com vi-paren-match backward-char "[])}]" forward-char backward-sexp error ""] 14))

(defun vi-forward-sentence (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊÄ
#*‡" [val arg com com-point nil p-val getcom move-marker forward-sentence execute-com vi-forward-sentence] 8))

(defun vi-backward-sentence (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊÄ
#*‡" [val arg com com-point nil p-val getcom move-marker backward-sentence execute-com vi-backward-sentence] 8))

(defun vi-forward-paragraph (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊÄ
#*‡" [val arg com com-point nil p-val getCom move-marker forward-paragraph execute-com vi-forward-paragraph] 8))

(defun vi-backward-paragraph (arg) (interactive "P") (byte-code "ĈÅ	!Æ	!
…Ç`\"ˆÈ!ˆ
… ÉÊÄ
#*‡" [val arg com com-point nil p-val getCom move-marker backward-paragraph execute-com vi-backward-paragraph] 8))

(defun vi-scroll (arg) "\
" (interactive "p") (byte-code "ÁˆÂVƒÂV…à ˆS‰ˆ‚‚-ÂV…-Ä ˆT‰ˆ‚‡" [arg nil 0 scroll-up scroll-down] 5))

(defun vi-scroll-back (arg) "\
" (interactive "p") (byte-code "ÁˆÂ[!‡" [arg nil vi-scroll] 2))

(defun vi-scroll-down (arg) "\
" (interactive "P") (byte-code "Áˆ?ƒÂÃÄ Å\"!‚Â!‡" [arg nil scroll-down / window-height 2] 5))

(defun vi-scroll-down-one (arg) "\
" (interactive "p") (byte-code "ÁˆÂ!‡" [arg nil scroll-down] 2))

(defun vi-scroll-up (arg) "\
" (interactive "P") (byte-code "Áˆ?ƒÂÃÄ Å\"!‚Â!‡" [arg nil scroll-up / window-height 2] 5))

(defun vi-scroll-up-one (arg) "\
" (interactive "p") (byte-code "ÁˆÂ!‡" [arg nil scroll-up] 2))

(defun buffer-in-two-windows nil (interactive) (byte-code "ÀˆÁ ˆÂÀ!‡" [nil delete-other-windows split-window-vertically] 3))

(defun vi-search-forward (arg) "\
(ARG) Search a string forward.  ARG is used to find the ARG's occurence
of the string.  Default is vanilla search.  Search mode can be toggled by
giving null search string." (interactive "P") (byte-code "ȈÉ	!Ê	!Ä˃̂Í!‰ˆÎ
Ï\"ƒ;?‰ˆÐÑÒƒ5Ó‚6Ô\"!‚QÕ
Ä#ˆ
…QÖ× \"ˆØÙ
#*‡" [val arg com s-forward t s-string re-search com-point nil P-val getcom vi-read-string "RE-/" "/" string= "" message format "Search mode changed to %s search." "regular expression" "vanilla" vi-search move-marker mark execute-com vi-search-next] 13))

(defun vi-search-backward (arg) "\
(ARG) Search a string backward.  ARG is used to find the ARG's occurence
of the string.  Default is vanilla search.  Search mode can be toggled by
giving null search string." (interactive "P") (byte-code "ĈÈ	!É	!Äʃ˂Ì!‰ˆÍ
Î\"ƒ;?‰ˆÏÐу5Ò‚6Ó\"!‚QÔ
Ä#ˆ
…QÕÖ \"ˆ×Ø
#*‡" [val arg com s-forward nil s-string re-search com-point P-val getcom vi-read-string "RE-?" "?" string= "" message format "Search mode changed to %s search." "regular expression" "vanilla" vi-search move-marker mark execute-com vi-search-next] 13))

(defun vi-search (string forward arg &optional no-offset init-point) "\
(STRING FORWARD COUNT &optional NO-OFFSET) Search COUNT's occurrence of
STRING.  Search will be forward if FORWARD, otherwise backward." (byte-code "Ë	!Ì	!Í	!?
?	†`
ƒ(ÎÏÐ�‚,ÎÑÒ�.‡" [val arg com null-arg offset no-offset case-fold-search vi-case-fold-search start-point init-point forward p-val getcom P-val conditions (byte-code "…m?…Æ ˆ	ƒÇ
ÃÃ$ˆÈ
!‚'É
ÃÃ$ˆÊ
!ˆË
!‡" [offset re-search string nil val start-point forward-char re-search-forward re-search-backward search-forward search-backward push-mark] 8) ((search-failed (byte-code "…	ƒebˆÈ
ÉBÅ%‚\"bˆÊËA\"‡" [null-arg vi-search-wrap-around string forward com t start-point conditions vi-search 1 signal search-failed] 6))) (byte-code "ƒ
Å	ÂÂ$‚Æ	ÂÂ$ˆÇ!‡" [re-search string nil val start-point re-search-backward search-backward push-mark] 6) ((search-failed (byte-code "…	ƒdbˆÈ
ÉBÅ%‚\"bˆÊËA\"‡" [null-arg vi-search-wrap-around string forward com t start-point conditions vi-search 1 signal search-failed] 6)))] 9))

(defun vi-search-next (arg) (interactive "P") (byte-code "ňÆ	!Ç	!?…ÈÉ!ˆÊ	#ˆ
…\"ËÌ
#*‡" [val arg com s-string s-forward nil p-val getcom error "No previous search string." vi-search execute-com vi-search-next] 8))

(defun vi-search-Next (arg) (interactive "P") (byte-code "ňÆ	!Ç	!?…ÈÉ!ˆÊ?	#ˆ
…#ËÌ
#*‡" [val arg com s-string s-forward nil p-val getcom error "No previous search string." vi-search execute-com vi-search-Next] 8))

(defun vi-switch-to-buffer nil (interactive) (byte-code "ÁˆÁÂÃÄÅÆp!!\"!‰ˆÇ!ˆÈ )‡" [buffer nil read-buffer format "switch to buffer (%s): " buffer-name other-buffer switch-to-buffer change-mode-to-vi] 7))

(defun vi-switch-to-buffer-other-window nil (interactive) (byte-code "ÁˆÁÂÃÄÅÆp!!\"!‰ˆÇ!ˆÈ )‡" [buffer nil read-buffer format "Switch to buffer (%s): " buffer-name other-buffer switch-to-buffer-other-window change-mode-to-vi] 7))

(defun vi-kill-buffer nil (interactive) (byte-code "ˆÂÂÃÄÅÁp!\"!‰ˆ	?ƒp‚Æ	!‰ˆ?…)ÇÈ	\"ˆÉ!ƒ6ÇÊ!‚9Ë!*‡" [buffer buffer-name nil read-buffer format "Kill buffer (%s): " get-buffer error "Buffer %s nonexistent." buffer-modified-p "I can't kill modified buffer." kill-buffer] 9))

(defun vi-find-file nil (interactive) (byte-code "ÁˆÁÂÃ!‰ˆÄÅ!!ˆÆ )‡" [file nil read-file-name "visit file: " switch-to-buffer find-file-noselect change-mode-to-vi] 5))

(defun vi-find-file-other-window nil (interactive) (byte-code "ÁˆÁÂÃ!‰ˆÄÅ!!ˆÆ )‡" [file nil read-file-name "Visit file: " switch-to-buffer-other-window find-file-noselect change-mode-to-vi] 5))

(defun vi-info-on-file nil "\
Give information of the file associated to the current buffer." (interactive) (byte-code "ÀˆÁÂà ƒà ‚ÄÅe`\"TÅed\"T$‡" [nil message "\"%s\" line %d of %d" buffer-file-name "" count-lines] 10))

(defun vi-yank (text) "\
yank TEXT silently." (byte-code "ŠÁ`!ˆcˆÂ )ˆÃÄ!‡" [text push-mark-silent exchange-point-and-mark skip-chars-forward " 	"] 4))

(defun vi-put-back (arg) (interactive "P") (byte-code "ƈÉ	!ƒ#ÊX…ËXƒÊZ8‚ Ì!‚%@
?…Aƒ>ƉˆÍÎ
\")‚AÍÏ!ˆÆ‰ˆÐ
!ƒUÑÒ!ˆÓ ‚al?…\\m?…aÔ ˆÕÆF‰ˆÖV…ƒ×
!ˆS‰ˆ‚n)*‡" [val arg text use-register kill-ring-yank-pointer reg nil d-com count p-val 49 57 get-register error "Nothing in register %c" "" end-with-a-newline-p next-line 1 beginning-of-line forward-char vi-put-back 0 vi-yank] 12))

(defun vi-Put-back (arg) (interactive "P") (byte-code "ƈÉ	!ƒ#ÊX…ËXƒÊZ8‚ Ì!‚%@
?…Aƒ>ƉˆÍÎ
\")‚AÍÏ!ˆÆ‰ˆÐ
!…NÑ ˆÒÆF‰ˆÓV…pÔ
!ˆS‰ˆ‚[)*‡" [val arg text use-register kill-ring-yank-pointer reg nil d-com count p-val 49 57 get-register error "Nothing in register %c" "" end-with-a-newline-p beginning-of-line vi-Put-back 0 vi-yank] 10))

(defun vi-delete-char (arg) (interactive "P") (byte-code "ÈÆ	!ÇÃE‰ˆ…6ÈX…ÉXƒ*ÊË\\``ZÃ$‚2Ì``ZÃ$ˆÃ‰ˆÍÅ\")‡" [val arg d-com nil use-register t p-val vi-delete-char 65 90 vi-append-to-register 32 copy-to-register delete-char] 7))

(defun vi-delete-backward-char (arg) (interactive "P") (byte-code "ÈÆ	!ÇÃE‰ˆ…6ÈX…ÉXƒ*ÊË\\``\\Ã$‚2Ì``\\Ã$ˆÃ‰ˆÍÅ\")‡" [val arg d-com nil use-register t p-val vi-delete-backward-char 65 90 vi-append-to-register 32 copy-to-register delete-backward-char] 7))

(defun vi-join-lines (arg) "\
(ARG)  Join this line to next, if ARG is nil.  Otherwise, join
 ARG lines" (interactive "*P") (byte-code "ÈÅ	!ÆÃE‰ˆ?ƒÇ‚SÈV…<É ˆm?…3ÊÇ!ˆË``S\"ˆÌ ˆS‰ˆ‚))‡" [val arg d-com nil count P-val vi-join-lines 1 0 end-of-line forward-line delete-region fixup-whitespace] 8))

(defun vi-change (beg end) (byte-code "ÃÄÅÆ	
\"\"!‰ˆÇ	
\"‡" [c-string beg end vi-read-string format "%s => " buffer-substring vi-change-subr] 6))

(defun vi-change-subr (beg end) (byte-code "…Æ	
Ã$ˆÃ‰ˆÇ	
\"ˆÈ‰ˆÉ
!‡" [use-register beg end nil this-command c-string copy-to-register kill-region vi-change insert-string] 5))

(defun vi-query-replace nil "\
()  Query replace.  If you supply null string as the string to be
replaced, the query replace mode will toggle between string replace
and regexp replace." (interactive) (byte-code "ˆÂÃ	ƒ
Ä‚Å!‰ˆÆÇ\"ƒ-	?‰ˆÈÉ	ƒ(Ê‚)Ë\"‚F	ƒ=ÌÃÍÎ\"!\"‚FÏÃÍÐ\"!\")‡" [str re-query-replace nil vi-read-string "Query replace regexp: " "Query replace: " string= "" message "Query replace mode changed to %s." "regexp replace" "string replace" query-replace-regexp format "Query replace regexp \"%s\" with: " query-replace "Query replace \"%s\" with: "] 12))

(defun vi-mark-beginning-of-buffer nil (interactive) (byte-code "ÀˆÁ`!ˆebˆÂ ˆÃÄ!‡" [nil set-mark exchange-point-and-mark message "mark set at the beginning of buffer"] 4))

(defun vi-mark-end-of-buffer nil (interactive) (byte-code "ÀˆÁ`!ˆdbˆÂ ˆÃÄ!‡" [nil set-mark exchange-point-and-mark message "mark set at the end of buffer"] 4))

(defun vi-mark-point (char) (interactive "c") (byte-code "ˆÃX…ÄXƒÅÃÆZZ!‚SÇUƒ#È ‚SÉUƒ.Ê ‚SËUƒ9Ì ‚SÍUƒEÎÆ!‚SÏUƒPÐ ‚SÑÒ!‡" [char t nil 97 122 point-to-register 1 60 vi-mark-beginning-of-buffer 62 vi-mark-end-of-buffer 46 push-mark 44 set-mark-command 68 mark-defun error ""] 8))

(defun vi-goto-mark (arg) (interactive "P") (byte-code "ÈrÄ
!Å	Ã#*‡" [char com arg nil getcom vi-goto-mark-subr] 5))

(defun vi-goto-mark-and-skip-white (arg) (interactive "P") (byte-code "ĈrÅ
!Æ	Ã#*‡" [char com arg t nil getCom vi-goto-mark-subr] 5))

(defun vi-goto-mark-subr (char com skip-white) (byte-code "ÇX…	ÈXƒVp
…É`\"ˆÊÇËZZ!bˆ…&Ì ˆÍ ˆ
…RÎ	p\"ƒEÏƒ>Ђ?ÑÅ
#‚RÒ	!ˆbˆÍ ˆÓÔ!)‚¡?…^ÕUƒy
…iÉ`\"ˆÖ ˆ
…vÏÑÅ
#‚¡…€×Uƒž
…‹É`\"ˆÖ ˆÌ ˆ
…›ÏÐÅ
#‚¡ÓÔ!‡" [char buff com com-point skip-white nil t 97 122 move-marker register-to-point 1 back-to-indentation change-mode-to-vi equal execute-com vi-goto-mark-and-skip-white vi-goto-mark switch-to-buffer error "" 96 exchange-point-and-mark 39] 19))

(defun vi-exchange-point-and-mark nil (interactive) (byte-code "ÀˆÁ ˆÂ ‡" [nil exchange-point-and-mark back-to-indentation] 3))

(defun vi-keyboard-quit nil (interactive) (byte-code "ÁˆÁ‰ˆÂ ‡" [use-register nil keyboard-quit] 2))

(defun ctl-c-equivalent (arg) (interactive "P") (byte-code "ÁˆÂÃ\"‡" [arg nil ctl-key-equivalent ""] 3))

(defun ctl-x-equivalent (arg) (interactive "P") (byte-code "ÁˆÂÃ\"‡" [arg nil ctl-key-equivalent ""] 3))

(defun ctl-key-equivalent (key arg) (byte-code "rÆX…ÇX…ÆÈZZ‰ˆ
‰ˆÉÊËÌ
Í!##!)‡" [char prefix-arg arg emacs-local-map global-map key 65 90 1 command-execute get-editor-command format "%s%s" char-to-string] 9))

(defun delete-backward-word (arg) (interactive "p") (byte-code "ÁˆŠÂ`!ˆÃ!ˆÄ`Å \")‡" [arg nil set-mark backward-word delete-region mark] 6))

(set (quote vi-command-mode-map) (make-keymap))

(define-key vi-command-mode-map "
" (quote beginning-of-line))

(define-key vi-command-mode-map "" (quote vi-scroll-back))

(define-key vi-command-mode-map "" (quote vi-ctl-c))

(define-key vi-command-mode-map "" (quote vi-scroll-up))

(define-key vi-command-mode-map "" (quote vi-scroll-up-one))

(define-key vi-command-mode-map "" (quote vi-scroll))

(define-key vi-command-mode-map "" (quote vi-keyboard-quit))

(define-key vi-command-mode-map "" (quote help-command))

(define-key vi-command-mode-map "
" (quote vi-scroll-back))

(define-key vi-command-mode-map "" (quote vi-other-window))

(define-key vi-command-mode-map "" (quote vi-ctl-open-line))

(define-key vi-command-mode-map "" (quote vi-scroll-down))

(define-key vi-command-mode-map "" (quote vi-ctl-x))

(define-key vi-command-mode-map "" (quote vi-scroll-down-one))

(define-key vi-command-mode-map "" (quote change-mode-to-emacs))

(define-key vi-command-mode-map "" (quote vi-ESC))

(define-key vi-command-mode-map " " (quote vi-scroll))

(define-key vi-command-mode-map "!" (quote vi-command-argument))

(define-key vi-command-mode-map "\"" (quote vi-command-argument))

(define-key vi-command-mode-map "#" (quote vi-command-argument))

(define-key vi-command-mode-map "$" (quote vi-goto-eol))

(define-key vi-command-mode-map "%" (quote vi-paren-match))

(define-key vi-command-mode-map "&" (quote vi-nil))

(define-key vi-command-mode-map "'" (quote vi-goto-mark-and-skip-white))

(define-key vi-command-mode-map "(" (quote vi-backward-sentence))

(define-key vi-command-mode-map ")" (quote vi-forward-sentence))

(define-key vi-command-mode-map "*" (quote call-last-kbd-macro))

(define-key vi-command-mode-map "+" (quote vi-next-line-at-bol))

(define-key vi-command-mode-map "," (quote vi-comma))

(define-key vi-command-mode-map "-" (quote vi-previous-line-at-bol))

(define-key vi-command-mode-map "." (quote vi-repeat))

(define-key vi-command-mode-map "/" (quote vi-search-forward))

(define-key vi-command-mode-map "0" (quote vi-beginning-of-line))

(define-key vi-command-mode-map "1" (quote vi-digit-argument))

(define-key vi-command-mode-map "2" (quote vi-digit-argument))

(define-key vi-command-mode-map "3" (quote vi-digit-argument))

(define-key vi-command-mode-map "4" (quote vi-digit-argument))

(define-key vi-command-mode-map "5" (quote vi-digit-argument))

(define-key vi-command-mode-map "6" (quote vi-digit-argument))

(define-key vi-command-mode-map "7" (quote vi-digit-argument))

(define-key vi-command-mode-map "8" (quote vi-digit-argument))

(define-key vi-command-mode-map "9" (quote vi-digit-argument))

(define-key vi-command-mode-map ":" (quote vi-ex))

(define-key vi-command-mode-map ";" (quote vi-semi-colon))

(define-key vi-command-mode-map "<" (quote vi-command-argument))

(define-key vi-command-mode-map "=" (quote vi-command-argument))

(define-key vi-command-mode-map ">" (quote vi-command-argument))

(define-key vi-command-mode-map "?" (quote vi-search-backward))

(define-key vi-command-mode-map "j" (quote vi-nil))

(define-key vi-command-mode-map "A" (quote vi-Append))

(define-key vi-command-mode-map "B" (quote vi-backward-Word))

(define-key vi-command-mode-map "C" (quote ctl-c-equivalent))

(define-key vi-command-mode-map "D" (quote vi-kill-line))

(define-key vi-command-mode-map "E" (quote vi-end-of-Word))

(define-key vi-command-mode-map "F" (quote vi-find-char-backward))

(define-key vi-command-mode-map "G" (quote vi-goto-line))

(define-key vi-command-mode-map "H" (quote vi-window-top))

(define-key vi-command-mode-map "I" (quote vi-Insert))

(define-key vi-command-mode-map "J" (quote vi-join-lines))

(define-key vi-command-mode-map "K" (quote vi-kill-buffer))

(define-key vi-command-mode-map "L" (quote vi-window-bottom))

(define-key vi-command-mode-map "M" (quote vi-window-middle))

(define-key vi-command-mode-map "N" (quote vi-search-Next))

(define-key vi-command-mode-map "O" (quote vi-Open-line))

(define-key vi-command-mode-map "P" (quote vi-Put-back))

(define-key vi-command-mode-map "Q" (quote vi-query-replace))

(define-key vi-command-mode-map "R" (quote vi-replace-string))

(define-key vi-command-mode-map "S" (quote vi-switch-to-buffer-other-window))

(define-key vi-command-mode-map "T" (quote vi-goto-char-backward))

(define-key vi-command-mode-map "U" (quote vi-nil))

(define-key vi-command-mode-map "V" (quote vi-find-file-other-window))

(define-key vi-command-mode-map "W" (quote vi-forward-Word))

(define-key vi-command-mode-map "X" (quote ctl-x-equivalent))

(define-key vi-command-mode-map "Y" (quote vi-yank-line))

(define-key vi-command-mode-map "ZZ" (quote save-buffers-kill-emacs))

(define-key vi-command-mode-map "[" (quote vi-nil))

(define-key vi-command-mode-map "\\" (quote escape-to-emacs))

(define-key vi-command-mode-map "]" (quote vi-nil))

(define-key vi-command-mode-map "^" (quote vi-bol-and-skip-white))

(define-key vi-command-mode-map "_" (quote vi-nil))

(define-key vi-command-mode-map "`" (quote vi-goto-mark))

(define-key vi-command-mode-map "a" (quote vi-append))

(define-key vi-command-mode-map "b" (quote vi-backward-word))

(define-key vi-command-mode-map "c" (quote vi-command-argument))

(define-key vi-command-mode-map "d" (quote vi-command-argument))

(define-key vi-command-mode-map "e" (quote vi-end-of-word))

(define-key vi-command-mode-map "f" (quote vi-find-char-forward))

(define-key vi-command-mode-map "g" (quote vi-info-on-file))

(define-key vi-command-mode-map "h" (quote vi-backward-char))

(define-key vi-command-mode-map "i" (quote vi-insert))

(define-key vi-command-mode-map "j" (quote vi-next-line))

(define-key vi-command-mode-map "k" (quote vi-previous-line))

(define-key vi-command-mode-map "l" (quote vi-forward-char))

(define-key vi-command-mode-map "m" (quote vi-mark-point))

(define-key vi-command-mode-map "n" (quote vi-search-next))

(define-key vi-command-mode-map "o" (quote vi-open-line))

(define-key vi-command-mode-map "p" (quote vi-put-back))

(define-key vi-command-mode-map "q" (quote vi-nil))

(define-key vi-command-mode-map "r" (quote vi-replace-char))

(define-key vi-command-mode-map "s" (quote vi-switch-to-buffer))

(define-key vi-command-mode-map "t" (quote vi-goto-char-forward))

(define-key vi-command-mode-map "u" (quote vi-undo))

(define-key vi-command-mode-map "v" (quote vi-find-file))

(define-key vi-command-mode-map "w" (quote vi-forward-word))

(define-key vi-command-mode-map "x" (quote vi-delete-char))

(define-key vi-command-mode-map "y" (quote vi-command-argument))

(define-key vi-command-mode-map "zH" (quote vi-line-to-top))

(define-key vi-command-mode-map "zM" (quote vi-line-to-middle))

(define-key vi-command-mode-map "zL" (quote vi-line-to-bottom))

(define-key vi-command-mode-map "z
" (quote vi-line-to-top))

(define-key vi-command-mode-map "z." (quote vi-line-to-middle))

(define-key vi-command-mode-map "z-" (quote vi-line-to-bottom))

(define-key vi-command-mode-map "{" (quote vi-backward-paragraph))

(define-key vi-command-mode-map "|" (quote vi-goto-col))

(define-key vi-command-mode-map "}" (quote vi-forward-paragraph))

(define-key vi-command-mode-map "~" (quote vi-nil))

(define-key vi-command-mode-map "" (quote vi-delete-backward-char))

(define-key ctl-x-map "3" (quote buffer-in-two-windows))

(define-key ctl-x-map "	" (quote insert-file))

(defun vip-version nil (interactive) (byte-code "ÀˆÁÂ!‡" [nil message "VIP version 2.7 of Feb 10, 1987"] 2))

(defvar ex-token-type nil "\
type of token.  if non-nil, gives type of address.  if nil, it
is a command.")

(defvar ex-token nil "\
value of token.")

(defvar ex-addresses nil "\
list of ex addresses")

(defvar ex-flag nil "\
flag for ex flag")

(defvar ex-buffer nil "\
name of ex buffer")

(defvar ex-count nil "\
value of ex count")

(defvar ex-g-flag nil "\
flag for global command")

(defvar ex-g-variant nil "\
if t global command is executed on lines not matching ex-g-pat")

(defvar ex-reg-exp nil "\
save reg-exp used in substitute")

(defvar ex-repl nil "\
replace pattern for substitute")

(defvar ex-g-pat nil "\
pattern for global command")

(defvar ex-map (make-sparse-keymap) "\
save commnads for mapped keys")

(defvar ex-tag nil "\
save ex tag")

(defvar ex-file nil)

(defvar ex-variant nil)

(defvar ex-offset nil)

(defvar ex-append nil)

(defun vi-nil nil (interactive) (byte-code "ÀˆÁÂ!‡" [nil error ""] 2))

(defun looking-back (str) "\
(STR)  returns t if looking back reg-exp STR before point." (byte-code "ŠÃÁÂ#)…`ÄÅ!U‡" [str nil t re-search-backward match-end 0] 4))

(defun check-sub (str) "\
check if ex-token is an initial segment of STR" (byte-code "	G
GX…Ä	
ÅO\"ƒ
‰‚Ɖ)‡" [length ex-token str ex-token-type string= 0 "non-command"] 5))

(defun get-ex-com-subr nil "\
get a complete ex command" (byte-code "Ã`!ˆÄÅ!ˆÆ‰ˆÇ`È \"‰ˆÉ ˆÊË!ƒ;ÊÌ!ƒ)ÍÎ!‚8ÊÏ!ƒ5ÍÐ!‚8ÍÑ!‚xÊÒ!ƒGÓ‰‚xÊÔ!ƒ_ÊÕ!ƒYÍÖ!‚\\Í×!‚xÊØ!ƒkÍÙ!‚xÊÚ!ƒƒÊÛ!ƒ}ÍÛ!‚€ÍÜ!‚xÊÝ!ƒ�ÍÞ!‚xÊß!ƒ›Íà!‚xÊá!ƒ§Íâ!‚xÊã!ƒ³Íä!‚xÊå!ƒ¿Íæ!‚xÊç!ƒãÊè!ƒÑÍè!‚àÊé!ƒÝÍê!‚àÍë!‚xÊì!ƒûÊí!ƒõÍî!‚øÍï!‚xÊð!ƒ
Íñ!‚xÊò!ƒ+
Êó!ƒ
Íô!‚(
Êõ!ƒ%
Íö!‚(
Í÷!‚xÊø!ƒ7
Íù!‚xÊú!ƒ[
Êû!ƒI
Íü!‚X
Êý!ƒU
Íþ!‚X
Íÿ!‚xÊ�@!ƒ«
Ê�A!ƒs
Í�B!‚¨
Ê�C!ƒƒ
Í�D!‚¨
Ê�E!ƒ“
Í�F!‚¨
Ê�G!ƒ£
Í�H!‚¨
Í�I!‚xÊ�J!ƒË
Ê�K!ƒÃ
Í�L!‚È
Í�J!‚xÊ�M!ƒû
Ê�N!ƒã
Í�O!‚ø
Ê�P!ƒó
Í�Q!‚ø
Í�R!‚xÊ�S!ƒ+Ê�T!ƒÍ�U!‚(Ê�V!ƒ#Í�W!‚(Í�S!‚xÊ�X!ƒKÊ�Y!ƒCÍ�Y!‚HÍ�Z!‚xÊ�[!ƒ[Í�\\!‚xÊ�]!ƒkÍ�^!‚xÊ�_!…xÍ�_!ˆÉ ‡" [ex-token-type ex-token t set-mark re-search-forward "[a-z][a-z]*" "command" buffer-substring mark exchange-point-and-mark looking-at "a" "ab" check-sub "abbreviate" "ar" "args" "append" "[bh]" "non-command" "c" "co" "copy" "change" "d" "delete" "e" "ex" "edit" "f" "file" "g" "global" "i" "insert" "j" "join" "l" "list" "m" "map" "mar" "mark" "move" "n" "nu" "number" "next" "o" "open" "p" "pre" "preserve" "pu" "put" "print" "q" "quit" "r" "rec" "recover" "rew" "rewind" "read" "s" "se" "set" "sh" "shell" "so" "source" "st" "stop" "substitute" "t" "ta" "tag" "u" "una" "unabbreviate" "unm" "unmap" "undo" "v" "ve" "version" "vi" "visual" "w" "wq" "write" "x" "xit" "y" "yank" "z"] 96))

(defun get-ex-token nil "\
get an ex-token which is either an address or a command.
a token has type (command, address, end-mark) and value." (byte-code "Å‹‡" [ex-token-type ex-token t cont nil ((byte-code "ÅÆ!ˆÇÈ!ˆÉÊ!ƒˉˆÌg!‰ˆÍÎ!‚ÉÏ!ƒ)Ð ‚ÉÑ!ƒ9ÍÎ!ˆÒ‰‚ÉÓ!ƒmÔ`!ˆÕÖ!ˆ×Ø\"ƒRÙ‚^×Ú\"ƒ]Û‚^܉ˆÝÞ`ß \"!‰‚Éà!ƒ}ÍÎ!ˆá‰‚Éâ!ƒ�ÍÎ!ˆã‰‚Éä!ƒÇÉå!†œÉæ!ƒ±ÍÎ!ˆçè!ˆéÎ!ˆØ‰‚ÄÉê!ƒÁÍÎ!ˆØ‰‚Äëì!‚Éí!ƒ

Éî!†ÖÉï!ƒëÍÎ!ˆçè!ˆéÎ!ˆÚ‰‚þÉð!ƒûÍÎ!ˆÚ‰‚þëì!‚Éñ!ƒJ
ÍÎ!ˆÔ`!ˆÂl?…
…,
Õò!ˆóô!?…(
ĉˆ‚
)ˆéÎ!ˆÞ`ß \"‰ˆÉñ!…C
ÍÎ!ˆõ‰‚Éö!ƒ•
ÍÎ!ˆÔ`!ˆÂl?…`
…„
Õ÷!ˆóø!?…q
ĉˆéÎ!ˆÉù!?…€
ÍÎ!ˆ‚Z
)ˆú‰ˆÞ`Sß \"‰‚Éû!ƒ¥
ÍÎ!ˆü‰‚Éý!ƒµ
ÍÎ!ˆþ‰‚Éÿ!ƒË
ˉˆÌg!‰ˆÍÎ!‚É�@!ƒ�A‰ˆÍÎ!ˆÉ�@!ƒë
ĉ‚ü
ÉÏ!ƒ÷
g‰‚ü
ë�B!ˆÍÎ!‚Éù!ƒ�C‰ˆ�D‰‚ë�E!‡" [ex-token-type ex-token t cont nil switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" looking-at "[k#]" "command" char-to-string forward-char 1 "[a-z]" get-ex-com-subr "\\." "dot" "[0-9]" set-mark re-search-forward "[0-9]*" string= "plus" "add-number" "minus" "sub-number" "abs-number" string-to-int buffer-substring mark "\\$" "end" "%" "whole" "+" "+[-+]" "+[
|]" insert-string "1" backward-char "+[0-9]" error "Badly formed address" "-" "-[-+]" "-[
|]" "-[0-9]" "/" "[^/]*\\(/\\|
\\)" looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\/" "search-forward" "\\?" "[^\\?]*\\(\\?\\|
\\)" "[^\\\\]\\(\\\\\\\\\\)*\\\\\\?" "
" "search-backward" "," "comma" ";" "semi-colon" "[!=><&~]" "'" "goto-mark" "Marks are ' and a-z" "end-mark" "goto" "illegal token"] 75))] 1))

(defun vi-ex nil "\
ex commands within vi." (interactive) (byte-code "ÁˆÁÁ‰ˆÌÍ!ÁÆ`΋ˆÏ‰ˆÁ‰	ˆ
…ÅÐ ˆÑÒ\"†4ÑÓ\"ƒK…B	B‰	ˆÔ ˆÕ‹‚ÁÑÖ\"ƒ]×ØÙ
\"!‚ÁÑÚ\"ƒqde	BB‰	‚ÁÑÛ\"ƒŒ?ƒ‚`‚ƒ	B‰	‚ÁÑÜ\"ƒ°…œ‰ˆ?ƒ¦`‚§	B‰	‚ÁÝ\"…À‰)ˆ‚ ,‡" [ex-g-flag nil ex-g-variant com-str address cont t dot ex-token-type ex-addresses ex-token ans vi-read-string ":" ((byte-code "ÁÂ!ˆÃed\"ˆÄÅ\"ˆeb‡" [com-str switch-to-buffer " *ex-working-space*" delete-region insert "
"] 5)) "" get-ex-token string= "command" "end-mark" execute-ex-command ((byte-code "ÃÄ!ˆÅÆ!ˆÇÈ!ƒÉÊ!‚#ÇË!ƒ Á‰‚#ÌÍ!‡" [cont nil t switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" looking-at "|" forward-char 1 "
" error "Extra character at end of a command"] 7)) "non-command" error format "%s: Not an editor command" "whole" "comma" "semi-colon" get-ex-address-subr] 15))

(defun ex-search-address (forward) "\
search pattern and set address" (byte-code "ÃÄ\"ƒ	?ƒÅÆ!‚	‰‚‰ˆ
ƒ*ÇÈ!ˆÉ!‚1ÇÊ!ˆË!‡" [ex-token s-string forward string= "" error "No previous search string" next-line 1 re-search-forward -1 re-search-backward] 7))

(defun get-ex-pat nil "\
get a regular expression and set ex-variant if found" (byte-code "Æ‹‡" [ex-g-variant ex-g-flag cont t nil ex-token ((byte-code "ÆÇ!ˆÈÉ!ˆÊË!…?	?‰ˆÌÍ!ˆÈÉ!ˆÊÎ!ƒeÌÍ!ˆÏ`!ˆÃl?…4
…IÐÑ!ˆÒÓ!?…Eĉˆ‚.)ˆÔ `UƒVÕ‚\\Ö`SÔ \"‰ˆ×Í!‚hĉ‡" [ex-g-variant ex-g-flag cont t nil ex-token switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" looking-at "!" forward-char 1 "/" set-mark re-search-forward "[^/]*\\(/\\|
\\)" looking-back "[^\\\\]\\(\\\\\\\\\\)*\\\\/" mark "" buffer-substring backward-char] 16))] 1))

(defun get-ex-command nil "\
get an ex command" (byte-code "ˇ" [ex-token-type ex-token t ((byte-code "ÃÄ!ˆÅÆ!…
ÇÈ!ˆÉÊ!ˆÅË!ƒ)Ì ˆÍÎ\"…&ÏÐ	\"‚>ÅÑ!ƒ;Òg!‰ˆÇÈ!‚>ÏÓ!‡" [ex-token-type ex-token t switch-to-buffer " *ex-working-space*" looking-at "/" forward-char 1 skip-chars-forward " 	" "[a-z]" get-ex-com-subr string= "non-command" error "%s: not an editor command" "[!=><&~]" char-to-string "Could not find an ex command"] 13))] 1))

(defun get-ex-opt-gc nil "\
get an ex option g or c" (byte-code "ˇ" [ex-token t nil ((byte-code "ÃÄ!ˆÅÆ!…
ÇÈ!ˆÉÊ!ˆÅË!ƒ$ˉˆÇÈ!ˆÁ‚7ÅÌ!ƒ6̉ˆÇÈ!ˆÁ‚7‡" [ex-token t nil switch-to-buffer " *ex-working-space*" looking-at "/" forward-char 1 skip-chars-forward " 	" "g" "c"] 9))] 1))

(defun default-ex-addresses (&optional whole-flag) "\
compute default addresses.  whole-flag means whole buffer." (byte-code "?ƒ	ƒdeÂBB‚``ÂBB‰‚'A?…'@B‰‡" [ex-addresses whole-flag nil] 3))

(defun get-ex-address nil "\
get an ex-address and set ex-flag if a flag is found" (byte-code "`ÂȉˆÅ‰ˆ	…~É ˆÊË\"ƒ@ÊÌ\"†-ÊÍ\"†-ÊÎ\"ƒ:‰ˆÅ‰‚=ÏÐ!‚zÊÑ\"ƒNʼn‚zÊÒ\"ƒ\\ÏÓ!‚zÊÔ\"ƒjÏÕ!‚zÖ`\"…y‰)ˆ‚ˆ*‡" [address cont t ex-token ex-flag nil ex-token-type ans "" get-ex-token string= "command" "print" "list" "#" error "address expected" "end-mark" "whole" "a trailing address is expected" "comma" "Extra characters after an address" get-ex-address-subr] 15))

(defun get-ex-address-subr (old-address dot) "\
returns an address as a point" (byte-code "ÁÇ
È\"ƒ‰‚ÒÇ
É\"ƒ0ŠbˆÊËUƒ&
S‚'
!ˆ`‰)‚ÒÇ
Ì\"ƒGŠbˆÊ
[!ˆ`‰)‚ÒÇ
Í\"ƒjŠebˆ
ËUƒ^ˉ‚fÊ
S!ˆ`‰)‚ÒÇ
Î\"ƒwd‰‚ÒÇ
Ï\"ƒ‚Æ‚ÒÇ
Ð\"ƒ�Æ‚ÒÇ
Ñ\"ƒ ŠÒÆ!ˆ`‰)‚ÒÇ
Ó\"ƒ³ŠÒÁ!ˆ`‰)‚ÒÇ
Ô\"…ÒŠ
?ƒÅÕ ‚ÍÖ
×ØZZ!bˆ`‰)ˆ)‡" [address nil ex-token-type dot old-address ex-token t string= "dot" "add-number" next-line 0 "sub-number" "abs-number" "end" "plus" "minus" "search-forward" ex-search-address "search-backward" "goto-mark" exchange-point-and-mark register-to-point 97 1] 20))

(defun get-ex-buffer nil "\
get a buffer name and set ex-count and ex-flag if found" (byte-code "Á‰ˆÁ‰ˆÁ‰ˆÅ‹‡" [ex-buffer nil ex-count ex-flag t ((byte-code "ÄÅ!ˆÆÇ!ˆÈÉ!…g‰ˆÊË!ˆÆÇ!ˆÈÌ!…5Í`!ˆÎÏ!ˆÐÑ`Ò \"!‰ˆÆÇ!ˆÈÓ!…CɈÊË!ˆÈÔ!?…NÕÖ!‡" [ex-buffer ex-count ex-flag t switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" looking-at "[a-zA-Z]" forward-char 1 "[0-9]" set-mark re-search-forward "[0-9][0-9]*" string-to-int buffer-substring mark "[pl#]" "[
|]" error "Illegal extra characters"] 17))] 2))

(defun get-ex-count nil (byte-code "ÁÁÁ‰ˆÅ‹‡" [ex-variant nil ex-count ex-flag t ((byte-code "ÄÅ!ˆÆÇ!ˆÈÉ!…Á‰ˆÊË!ˆÆÇ!ˆÈÌ!…5Í`!ˆÎÏ!ˆÐÑ`Ò \"!‰ˆÆÇ!ˆÈÓ!…CÁ‰ˆÊË!ˆÈÔ!?…NÕÖ!‡" [ex-variant t ex-count ex-flag switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" looking-at "!" forward-char 1 "[0-9]" set-mark re-search-forward "[0-9][0-9]*" string-to-int buffer-substring mark "[pl#]" "[
|]" error "Illegal extra characters"] 17))] 2))

(defun get-ex-file nil "\
get a file name and set ex-variant, ex-append and ex-offset if found" (byte-code "ÁÁÁÁ‰ˆÆ‹‡" [ex-file nil ex-variant ex-append ex-offset t ((byte-code "ÅÆ!ˆÇÈ!ˆÉÊ!…Á‰ˆËÌ!ˆÇÈ!ˆÉÍ!…-ÁÁ‰ˆËÎ!ˆÇÈ!ˆÉÏ!…SËÌ!ˆÐ`!ˆÑÒ!ˆÓÌ!ˆÔ`Õ \"‰ˆËÌ!ˆÇÈ!ˆÐ`!ˆÑÒ!ˆÓÌ!ˆÔ`Õ \"‰‡" [ex-variant t ex-append ex-offset ex-file switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" looking-at "!" forward-char 1 ">>" 2 "+" set-mark re-search-forward "[ 	
]" backward-char buffer-substring mark] 24))] 2))

(defun execute-ex-command nil "\
execute ex command using the value of addresses." (byte-code "ÃÄ\"ƒÅ ‚_ÃÆ\"ƒÇÁ!‚_ÃÈ\"ƒ%É ‚_ÃÊ\"ƒ1Ë ‚_ÃÌ\"ƒ=Í ‚_ÃÎ\"ƒJÏÁ!‚_ÃÐ\"ƒWÑÐ!‚_ÃÒ\"ƒcÓ ‚_ÃÔ\"ƒoÓ ‚_ÃÕ\"ƒ{Ö ‚_Ã×\"ƒˆÇÂ!‚_ÃØ\"ƒ”Ù ‚_ÃÚ\"ƒ Û ‚_ÃÜ\"ƒ¬Ý ‚_ÃÞ\"ƒ¸ß ‚_Ãà\"ƒÄá ‚_Ãâ\"ƒÐã ‚_Ãä\"ƒÜå ‚_Ãæ\"ƒéÇÁ!‚_Ãç\"ƒõè ‚_Ãé\"ƒ

ê ‚_Ãë\"ƒ

ì ‚_Ãí\"ƒ
ÏÂ!‚_Ãî\"ƒ&
ï ‚_Ãð\"ƒ2
Ë ‚_Ãñ\"ƒ?
òÁ!‚_Ãó\"ƒL
òÂ!‚_Ãô\"ƒX
õ ‚_Ãö\"ƒd
÷ ‚_Ãø\"ƒp
ù ‚_Ãú\"ƒ}
Ñû!‚_Ãü\"ƒŠ
Ñý!‚_Ãþ\"ƒ—
ãÂ!‚_Ãÿ\"ƒ¥
ãÂÂ\"‚_Ã�@\"†Ï
Ã�A\"†Ï
Ã�B\"†Ï
Ã�C\"†Ï
Ã�D\"ƒá
�E�F�G\"!‚_Ã�H\"†AÃ�I\"†AÃ�J\"†AÃ�K\"†AÃ�L\"†AÃ�M\"†AÃ�N\"†AÃ�O\"†AÃ�P\"†AÃ�Q\"†AÃ�R\"ƒS�E�F�S\"!‚_�E�F�T\"!‡" [ex-token nil t string= "goto" ex-goto "copy" ex-copy "delete" ex-delete "edit" ex-edit "file" vi-info-on-file "global" ex-global "join" ex-line "k" ex-mark "mark" "map" ex-map "move" "put" ex-put "quit" ex-quit "read" ex-read "set" ex-set "shell" ex-shell "substitute" ex-substitute "stop" suspend-emacs "t" "tag" ex-tag "undo" vi-undo "unmap" ex-unmap "v" "version" vip-version "visual" "write" ex-write "wq" "yank" ex-yank "!" ex-command "=" ex-line-no ">" "right" "<" "left" "&" "~" "append" "args" "change" "insert" "open" error format "%s: no such command from VIP" "abbreviate" "list" "next" "print" "preserve" "recover" "rewind" "source" "unabbreviate" "xit" "z" "%s: not implemented in VIP" "%s: Not an editor command"] 92))

(defun ex-goto nil "\
ex goto command" (byte-code "?…
`ÁB‰ˆÂ`!ˆ@bˆÃ ‡" [ex-addresses nil push-mark beginning-of-line] 3))

(defun ex-copy (del-flag) "\
ex copy and move command.  del-flag means delete." (byte-code "Ë ˆÌ 
@
A@	bˆŠÍ!ˆÎÏ `\"ˆ† 
ƒ;ƒ0ÐÏ `\"‚5ÑÏ `\"ˆÒ‹‚MƒHÐ`Ï \"‚MÑ`Ï \"ˆ
…uÓ�Ô†`†`
ƒi@‚nÕ`Ï \"!‘ˆÖ×Ø�)ˆÙUƒ‚eb‚‹bˆÚÛ!ˆÜ ˆÝ@!+‡" [address end ex-addresses beg ex-g-flag ex-g-variant del-flag kill-ring-yank-pointer ex-g-pat t ex-flag default-ex-addresses get-ex-address set-mark enlarge-region mark kill-region copy-region-as-kill ((byte-code "ÆÇ!ˆÈed\"ˆÉ@!ˆebˆm?…VÊ ˆË`!ˆÌ ˆÍ	Î Â#ƒ?ƒ3ÏÐ!‚<Ì ˆÈ`Î T\"‚RƒIÏÐ!‚RÌ ˆÈ`Î T\"ˆ‚ˆ
ƒbÑed\"‚fÒed\"‡" [kill-ring-yank-pointer ex-g-pat t ex-g-flag ex-g-variant del-flag switch-to-buffer " *ex-working-space" delete-region insert-string end-of-line set-mark beginning-of-line re-search-forward mark next-line 1 kill-region copy-region-as-kill] 20)) "*copy text*" princ buffer-substring nil (byte-code "ÀÁ!ˆŠÂÃ!)‡" [vi-read-string "[Hit return to continue] " kill-buffer "*copy text*"] 3) ((quit (byte-code "ŠÁÂ!)ˆÃÄÀ\"‡" [nil kill-buffer "*copy text*" signal quit] 4))) 0 next-line 1 beginning-of-line insert-string] 20))

(defun ex-delete nil "\
ex delete" (byte-code "Í ˆÎ ˆ	@	A@
V…ÏÐ!ˆŠÑ
\"ˆÒ Ó ˆ†(
…Šm?…3`X…ŠÔ ˆÕ`!ˆÖ ˆ×Ø È#…O†Y
…Y?ƒ�	ƒuÖ ˆÕ`!ˆÙ	!ˆÚ`Ø \"‚~Ö ˆÚ`Ø T\"‚…Ø Tb)ˆ‚+)ˆ	ƒ�Õ`!ˆÙ	S!‚ Õ!ˆÑ`Ø \"ˆ
ƒÄÛ�ÜÝ`Ø \"!‘ˆÞßà�ˆŠáÛ!)‚ò…ìâX…ÔãXƒääå\\`Ø Ì$‚ìæ`Ø Ì$ˆÚ`Ø \")*‡" [end ex-addresses beg limit ex-g-flag ex-g-variant found ex-g-pat t ex-count ex-flag ex-buffer nil default-ex-addresses get-ex-buffer error "First address exceeds second" enlarge-region point-marker exchange-point-and-mark end-of-line set-mark beginning-of-line re-search-forward mark next-line delete-region " *delete text*" princ buffer-substring conditions (byte-code "ÀÁ!‡" [vi-read-string "[Hit return to continue] "] 2) ((quit (byte-code "ŠÀÁ!)ˆÂÃ!‡" [kill-buffer " *delete text*" error ""] 3))) kill-buffer 65 90 vi-append-to-register 32 copy-to-register] 37))

(defun ex-edit nil "\
ex-edit" (byte-code "Å ˆ?…Æ …	…ÇÈ!ˆÉ ˆÊË
P!!ˆÌ ˆebˆ…3Í‹ˆÎ bˆÏ ‡" [ex-variant buffer-file-name default-directory ex-file ex-offset get-ex-file buffer-modified-p error "No write since last change (:e! overrides)" change-mode-to-emacs switch-to-buffer find-file-noselect change-mode-to-vi ((byte-code "ÁÂ!ˆÃed\"ˆÄÅ\"ˆeb‡" [ex-offset switch-to-buffer " *ex-working-space*" delete-region insert "
"] 5)) get-ex-address beginning-of-line] 10))

(defun ex-global (variant) "\
ex global command" (byte-code "ƒÂĉ‚ĉˆÉ ˆ
?…ÊË!ˆÌ
Í\"ƒ9?ƒ1ÊÎ!‚6‰‚@

‰ˆÏ ˆÌ
Ð\"…NÊÑ!ˆ?…]deÂBB‰ˆÒ ‡" [variant ex-g-flag nil ex-g-variant t ex-token s-string ex-g-pat ex-addresses get-ex-pat error "Missing regular expression for global command" string= "" "No previous search string" get-ex-command "global" "Global within global not allowed" execute-ex-command] 10))

(defun ex-line (com) "\
ex line commands.  COM is join, shift-right or shift-left." (byte-code "Ì ˆÍ ˆ	@	A@Î
V…ÏÐ!ˆŠÑ
\"ˆÒ Ó ˆ
†+ƒºm?…6`X…·Ô ˆÕ`!ˆÖ ˆ×Ø È#ƒ�
ƒz	ƒlÖ ˆÕ`!ˆÙ	!ˆÚ
`Ø #‚wÖ ˆÚ
`Ø T#‚~Ø Tb‚³ƒ¯	ƒ¡Ö ˆÕ`!ˆÙ	!ˆÚ
`Ø #‚¬Ö ˆÚ
`Ø T#‚³Ø Tbˆ‚.‚ì	…ÇÕ`!ˆÙ	!ˆƒåÛ�ÜÝ`Ø \"!‘ˆÞßà�ˆŠáÛ!)‚ìÚ
`Ø #)ˆ`‰)ˆSbˆÖ +‡" [end ex-addresses beg point limit ex-g-flag ex-g-variant ex-g-pat t ex-count com ex-flag default-ex-addresses get-ex-count nil error "First address exceeds second" enlarge-region point-marker exchange-point-and-mark end-of-line set-mark beginning-of-line re-search-forward mark next-line ex-line-subr " *text*" princ buffer-substring conditions (byte-code "ÁÂ!ˆÃ`Ä #‡" [com vi-read-string "[Hit return to continue] " ex-line-subr mark] 6) ((quit (byte-code "À ‡" [ding] 2))) kill-buffer] 40))

(defun ex-line-subr (com beg end) (byte-code "ÅÆ\"ƒA	
^bˆm?…`	
]W…>Ç ˆ`	
]X…&m?…:ÈÉ!ˆÊ``S\"ˆ?…:Ë ˆ‚‚pÅÌ\"†LÅÍ\"…pÎ	
^	
]ÅÌ\"ƒa‚c[#ˆ	
]bˆÇ ˆÏÉ!‡" [com beg end ex-variant shift-width string= "join" end-of-line forward-line 1 delete-region fixup-whitespace "right" "left" indent-rigidly forward-char] 13))

(defun ex-mark nil "\
ex mark" (byte-code "Â	?…`ÂB‰ˆÃ‹ˆŠ	@bˆÄÅÆZZ!))‡" [char ex-addresses nil ((byte-code "ÁÂ!ˆÃÄ!ˆÅÆ!ƒ'g‰ˆÇÈ!ˆÃÄ!ˆÅÉ!?…$ÊË!‚6ÅÉ!ƒ3ÊÌ!‚6ÊÍ!‡" [char switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" looking-at "[a-z]" forward-char 1 "[
|]" error "Extra characters at end of \"k\" command" "\"k\" requires a following letter" "Mark must specify a letter"] 11)) point-to-register 97 1] 4))

(defun ex-map nil "\
ex map" (byte-code "ÄÄÅ‹ˆÆ
\"?…Ç
Æ\"†È#ˆÇÉÊËÌÍÎ	ÏEEBD!#*‡" [char string ex-map vi-command-mode-map nil ((byte-code "ÂÃ!ˆÄÅ!ˆÆg!‰ˆÇÈ!ˆÄÅ!ˆÉÊ!…ËÌ!ˆÍ`!ˆÎ ˆÏÈ!ˆÐÑ `\"‰‡" [char string switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" char-to-string forward-char 1 looking-at "[
|]" error "Missing rhs" set-mark end-of-buffer backward-char buffer-substring mark] 14)) lookup-key define-key vi-nil eval quote lambda (count) (interactive "p") execute-kbd-macro count] 14))

(defun ex-unmap nil "\
ex unmap" (byte-code "ÃÄ‹ˆÅ	\"?…ÆÇ!ˆÈ
Å	\"#ˆÈ	Ã#)‡" [char ex-map vi-command-mode-map nil ((byte-code "ÁÂ!ˆÃÄ!ˆÅg!‰ˆÆÇ!ˆÃÄ!ˆÈÉ!?… ÊË!‡" [char switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" char-to-string forward-char 1 looking-at "[
|]" error "Macro must be a character"] 8)) lookup-key error "That macro wasn't mapped" define-key] 8))

(defun ex-put nil "\
ex put" (byte-code "	?ƒ	`‚	@Ä ˆ‰ˆbˆÅUƒ\"ÆÇ!‚%ÈÇ!)‡" [point ex-addresses use-register ex-buffer get-ex-buffer 0 vi-Put-back 1 vi-put-back] 4))

(defun ex-quit nil "\
ex quit" (byte-code "ÂˈÄUƒÅÁ!‚Æ )‡" [char t nil ((byte-code "ÁÂ!ˆÃÄ!ˆg‰‡" [char switch-to-buffer " *ex-working-space*" skip-chars-forward " 	"] 4)) 33 kill-emacs save-buffers-kill-emacs] 3))

(defun ex-read nil "\
ex read" (byte-code "	?ƒ	`‚	@ÃÃÃbˆÇU?…ÈÉ!ˆÊ ˆË‹ˆ
ƒ1ÌÆ\"‚4Í
!,‡" [point ex-addresses variant nil command file t 0 next-line 1 beginning-of-line ((byte-code "ÄÅ!ˆÆÇ!ˆÈÉ!ƒ+Á‰ˆÊË!ˆÆÇ!ˆÌ`!ˆÍ ˆÎÏ `\"‰‚>Ì`!ˆÐÑ!ˆÒË!ˆÎ`Ï \"‰‡" [variant t command file switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" looking-at "!" forward-char 1 set-mark end-of-line buffer-substring mark re-search-forward "[ 	
]" backward-char] 16)) shell-command insert-file] 5))

(defun ex-set nil (byte-code "ÀÁÂÃ!ÀÄÅ!!E!‡" [eval setq read-variable "Variable: " read-minibuffer "Value: "] 7))

(defun ex-shell nil "\
ex shell" (byte-code "À ˆÁ ‡" [change-mode-to-emacs shell] 3))

(defun ex-substitute (&optional repeat r-flag) "\
ex substitute. if REPEAT use previous reg-exp which is ex-reg-exp or
s-string" (byte-code "ÃÃÃÃÃɂ٠ˆ?ƒ3ƒ)	‚+
‰‚hÚÛ\"ƒ@	‚B‰ˆ	‰
ˆÙ ˆ?ƒ`ÛÛ‰‚h‰ˆÜ …ƒÚÝ\"ƒ|̉‚̉ˆ‚iˆÞ ˆ
ƒ®Š…–@bˆß`!ˆà
S!ˆ`á ÃBB‰)‚Ï?ƒ¿``ÃBB‰‚ÏA?…Ï@B‰ˆ
‰ˆ@A@ÌÊâ\"ˆŠ`á ]bˆã )`á ^bˆ†
ƒ»
…¸
ä ˆß`!ˆå ˆæá Ì#…)
†4
…4
?ƒ 
ä ˆç ‰ˆå ˆ
ƒn
l?…R
æÌ#…k
?†]
èé!…g
`‰ˆê	!ˆ‚G
‚‰
æÌ#…‰
?†
èé!…‰
`‰ˆê	!ˆä ˆ`Uƒ›
ɂ�
ë ‚³
ä ˆ`Uƒ±
É‚³
ë )ˆ‚

‚$`W…$ä ˆç ‰ˆå ˆ
ƒÿ
l?…Ý
æÌ#…ö
?†è
èé!…ò
`‰ˆê	!ˆ‚Ò
ˆä ˆë ‚ æÌ#…?†èé!…`‰ˆê	!ˆä ˆë ˆ‚»
)),ˆ
….
bˆå ˆ…9ìí!-‡" [pat repl opt-g nil opt-c matched-pos repeat ex-token r-flag s-string ex-reg-exp ex-repl t ex-count ex-addresses G beg end cont eol-mark limit ex-g-flag ex-g-variant found ex-g-pat get-ex-pat string= "" get-ex-opt-gc "g" get-ex-count set-mark next-line mark enlarge-region point-marker end-of-line beginning-of-line re-search-forward dot-marker y-or-n-p "Replace? " replace-match forward-char message "done"] 47))

(defun ex-tag nil "\
ex tag" (byte-code "ÂˈÄÅ\"?…‰ˆÆ ˆÇÈÉ�)‡" [tag ex-tag nil ((byte-code "ÁÂ!ˆÃÄ!ˆÅ`!ˆÃÆ!ˆÇÈ `\"‰‡" [tag switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" set-mark "^ |	
" buffer-substring mark] 8)) string= "" change-mode-to-emacs conditions (byte-code "ÃÄ\"ƒÅ	Â\"‚Æ	!ˆÇ ‡" [tag ex-tag t string= "" find-tag find-tag-other-window change-mode-to-vi] 5) ((error (byte-code "Á ˆÂ!‡" [conditions change-mode-to-vi message-conditions] 3)))] 5))

(defun ex-write (q-flag) "\
ex write" (byte-code "ÉÀ!ˆÊ ˆË	Ì\"ƒ
?…ÍÎ!ˆ
‰‚\"Ï	!‰ˆË	 \"?…4Ð	!…4?…=ÍÑÒ	\"!ˆ
@
A@V…PÍÓ!ˆŠÔ\"ˆÕ`Ö 	À%)*ˆ
?…l	‰ˆ…t× ‡" [t ex-file buffer-file-name ex-variant end ex-addresses beg ex-append q-flag default-ex-addresses get-ex-file string= "" error "No file associated with this buffer" expand-file-name file-exists-p format "\"%s\" File exists - use w! to override" "First address exceeds second" enlarge-region write-region mark save-buffers-kill-emacs] 19))

(defun ex-yank nil "\
ex yank" (byte-code "É ˆÊ ˆ	@	A@
V…ËÌ!ˆŠÍ
\"ˆÎ ˆ†%…+ËÏ!ˆ
ƒ;Ð`!ˆÑ
S!‚>Ð!ˆÍ`Ò \"ˆ…MËÓ!ˆ…[Ô`Ò È$ˆÕ`Ò \")*‡" [end ex-addresses beg ex-g-flag ex-g-variant ex-count ex-flag ex-buffer nil default-ex-addresses get-ex-buffer error "First address exceeds second" enlarge-region exchange-point-and-mark "Can't yank within global" set-mark next-line mark "Extra chacters at end of command" copy-to-register copy-region-as-kill] 18))

(defun ex-command nil "\
execute shell command" (byte-code "ÅÆ‹ˆ	?ƒÇ!‚:	@	A@?…
‰ˆŠbˆÈ
!ˆÉ`Ê \"ˆË`Ê Ä$)ˆb*)‡" [command ex-addresses end beg t nil ((byte-code "ÁÂ!ˆÃÄ!ˆÅ`!ˆÆ ˆÇÈ `\"‰‡" [command switch-to-buffer " *ex-working-space*" skip-chars-forward " 	" set-mark end-of-line buffer-substring mark] 8)) shell-command set-mark enlarge-region mark shell-command-on-region] 10))

(defun ex-line-no nil "\
print line number" (byte-code "ÁÂÃe?ƒ
d‚@\"T\"‡" [ex-addresses message "%d" count-lines] 5))

(if (file-exists-p "~/.vip") (load "~/.vip"))