diff --git a/runtime/doc/autocmd.txt b/runtime/doc/autocmd.txt
index 2fae1e2..a0d3b63 100644
--- a/runtime/doc/autocmd.txt
+++ b/runtime/doc/autocmd.txt
@@ -1,4 +1,4 @@
-*autocmd.txt*   For Vim version 7.3.  Last change: 2012 Sep 05
+*autocmd.txt*   For Vim version 7.3.  Last change: 2013 Mar 13
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -730,11 +730,11 @@
 				moving to the first error. 
 				See |QuickFixCmdPost-example|.
 							*QuitPre*
-QuitPre				When using `:quit`, before deciding whether it
-				closes the current window or quits Vim.  Can
-				be used to close any non-essential window if
-				the current window is the last ordinary
-				window.
+QuitPre				When using `:quit`, `:wq` or `:qall`, before
+				deciding whether it closes the current window
+				or quits Vim.  Can be used to close any
+				non-essential window if the current window is
+				the last ordinary window.
 							*RemoteReply*
 RemoteReply			When a reply from a Vim that functions as
 				server was received |server2client()|.  The
diff --git a/runtime/doc/cmdline.txt b/runtime/doc/cmdline.txt
index c3627d4..4759702 100644
--- a/runtime/doc/cmdline.txt
+++ b/runtime/doc/cmdline.txt
@@ -1,4 +1,4 @@
-*cmdline.txt*   For Vim version 7.3.  Last change: 2013 Jan 17
+*cmdline.txt*   For Vim version 7.3.  Last change: 2013 Mar 16
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -964,7 +964,7 @@
 	\\$home		file "\\", followed by expanded $home
 
 ==============================================================================
-6. Command-line window				*cmdline-window* *cmdwin*
+7. Command-line window				*cmdline-window* *cmdwin*
 							*command-line-window*
 In the command-line window the command line can be edited just like editing
 text in any window.  It is a special kind of window, because you cannot leave
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 1a7cbb9..bc729d1 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1,4 +1,4 @@
-*eval.txt*	For Vim version 7.3.  Last change: 2013 Feb 20
+*eval.txt*	For Vim version 7.3.  Last change: 2013 Mar 10
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -2583,6 +2583,8 @@
 		which is 0 if the file was deleted successfully, and non-zero
 		when the deletion failed.
 		Use |remove()| to delete an item from a |List|.
+		To delete a line from the buffer use |:delete|.  Use |:exe|
+		when the line number is in a variable.
 
 							*did_filetype()*
 did_filetype()	Returns non-zero when autocommands are being executed and the
diff --git a/runtime/doc/motion.txt b/runtime/doc/motion.txt
index 522b717..265d530 100644
--- a/runtime/doc/motion.txt
+++ b/runtime/doc/motion.txt
@@ -1,4 +1,4 @@
-*motion.txt*    For Vim version 7.3.  Last change: 2012 Aug 04
+*motion.txt*    For Vim version 7.3.  Last change: 2013 Mar 07
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -104,13 +104,14 @@
 |Visual-mode|.
 
 You can use a ":" command for a motion.  For example "d:call FindEnd()".
-But this can't be redone with "." if the command is more than one line.
+But this can't be repeated with "." if the command is more than one line.
 This can be repeated: >
 	d:call search("f")<CR>
 This cannot be repeated: >
 	d:if 1<CR>
 	   call search("f")<CR>
 	endif<CR>
+Note that when using ":" any motion becomes characterwise exclusive.
 
 
 FORCING A MOTION TO BE LINEWISE, CHARACTERWISE OR BLOCKWISE
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 143656a..ac3d394 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 7.3.  Last change: 2013 Feb 28
+*options.txt*	For Vim version 7.3.  Last change: 2013 Mar 13
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -699,6 +699,10 @@
 	when the system locale is set to one of CJK locales.  See Unicode
 	Standard Annex #11 (http://www.unicode.org/reports/tr11).
 
+	Vim may set this option automatically at startup time when Vim is
+	compiled with the |+termresponse| feature and if |t_u7| is set to the
+	sescape sequense to request cursor position report.
+
 			*'antialias'* *'anti'* *'noantialias'* *'noanti'*
 'antialias' 'anti'	boolean (default: off)
 			global
diff --git a/runtime/doc/quickfix.txt b/runtime/doc/quickfix.txt
index 4738be0..47e110c 100644
--- a/runtime/doc/quickfix.txt
+++ b/runtime/doc/quickfix.txt
@@ -1,4 +1,4 @@
-*quickfix.txt*  For Vim version 7.3.  Last change: 2011 May 10
+*quickfix.txt*  For Vim version 7.3.  Last change: 2013 Mar 07
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index b69753a..a32a468 100644
--- a/runtime/doc/syntax.txt
+++ b/runtime/doc/syntax.txt
@@ -1,4 +1,4 @@
-*syntax.txt*	For Vim version 7.3.  Last change: 2013 Mar 01
+*syntax.txt*	For Vim version 7.3.  Last change: 2013 Mar 13
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -2928,6 +2928,35 @@
 Another cause of slow highlighting is due to syntax-driven folding; see
 |tex-folding| for a way around this.
 
+								*g:tex_fast*
+
+Finally, if syntax highlighting is still too slow, you may set >
+
+	:let g:tex_fast= ""
+
+in your .vimrc.  Used this way, the g:tex_fast variable causes the syntax
+highlighting script to avoid defining any regions and associated
+synchronization.  The result will be much faster syntax highlighting; the
+price: you will no longer have as much highlighting or any syntax-based
+folding, and you will be missing syntax-based error checking.
+
+You may decide that some syntax is acceptable; you may use the following table
+selectively to enable just some syntax highlighting: >
+
+    b : allow bold and italic syntax
+    c : allow texComment syntax
+    m : allow texMatcher syntax (ie. {...} and [...])
+    M : allow texMath syntax
+    p : allow parts, chapter, section, etc syntax
+    r : allow texRefZone syntax (nocite, bibliography, label, pageref, eqref)
+    s : allow superscript/subscript regions
+    S : allow texStyle syntax
+    v : allow verbatim syntax
+    V : allow texNewEnv and texNewCmd syntax
+<
+As an example, let g:tex_fast= "M" will allow math-associated highlighting
+but suppress all the other region-based syntax highlighting.
+
 					    *tex-morecommands* *tex-package*
  Tex: Want To Highlight More Commands? ~
 
@@ -3822,7 +3851,7 @@
 e	end of the matched pattern
 e+{nr}	end of the matched pattern plus {nr} chars to the right
 e-{nr}	end of the matched pattern plus {nr} chars to the left
-{nr}	(for "lc" only): start matching {nr} chars to the left
+{nr}	(for "lc" only): start matching {nr} chars right of the start
 
 Examples: "ms=s+1", "hs=e-2", "lc=3".
 
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 89ac4a9..cb2364a 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -964,6 +964,7 @@
 't_te'	term.txt	/*'t_te'*
 't_ti'	term.txt	/*'t_ti'*
 't_ts'	term.txt	/*'t_ts'*
+'t_u7'	term.txt	/*'t_u7'*
 't_ue'	term.txt	/*'t_ue'*
 't_us'	term.txt	/*'t_us'*
 't_ut'	term.txt	/*'t_ut'*
@@ -5182,6 +5183,7 @@
 cpo-x	options.txt	/*cpo-x*
 cpo-y	options.txt	/*cpo-y*
 cpo-{	options.txt	/*cpo-{*
+cpp.vim	syntax.txt	/*cpp.vim*
 crash-recovery	recover.txt	/*crash-recovery*
 creating-menus	gui.txt	/*creating-menus*
 credits	intro.txt	/*credits*
@@ -5658,6 +5660,7 @@
 ft-clojure-indent	indent.txt	/*ft-clojure-indent*
 ft-cobol-syntax	syntax.txt	/*ft-cobol-syntax*
 ft-coldfusion-syntax	syntax.txt	/*ft-coldfusion-syntax*
+ft-cpp-syntax	syntax.txt	/*ft-cpp-syntax*
 ft-csh-syntax	syntax.txt	/*ft-csh-syntax*
 ft-css-omni	insert.txt	/*ft-css-omni*
 ft-cweb-syntax	syntax.txt	/*ft-cweb-syntax*
@@ -5958,6 +5961,7 @@
 g:tar_secure	pi_tar.txt	/*g:tar_secure*
 g:tar_writeoptions	pi_tar.txt	/*g:tar_writeoptions*
 g:tex_conceal	syntax.txt	/*g:tex_conceal*
+g:tex_fast	syntax.txt	/*g:tex_fast*
 g:tex_isk	syntax.txt	/*g:tex_isk*
 g:var	eval.txt	/*g:var*
 g:vimball_home	pi_vimball.txt	/*g:vimball_home*
@@ -7975,6 +7979,7 @@
 t_tp	version4.txt	/*t_tp*
 t_ts	term.txt	/*t_ts*
 t_ts_old	version4.txt	/*t_ts_old*
+t_u7	term.txt	/*t_u7*
 t_ue	term.txt	/*t_ue*
 t_undo	version4.txt	/*t_undo*
 t_us	term.txt	/*t_us*
diff --git a/runtime/doc/term.txt b/runtime/doc/term.txt
index 362a189..de0313c 100644
--- a/runtime/doc/term.txt
+++ b/runtime/doc/term.txt
@@ -1,4 +1,4 @@
-*term.txt*      For Vim version 7.3.  Last change: 2011 Feb 16
+*term.txt*      For Vim version 7.3.  Last change: 2013 Mar 13
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -294,6 +294,8 @@
 		|termcap-cursor-shape|
 	t_RV	request terminal version string (for xterm)	*t_RV* *'t_RV'*
 		|xterm-8bit| |v:termresponse| |'ttymouse'| |xterm-codes|
+	t_u7	request cursor position (for xterm)		*t_u7* *'t_u7'*
+		see |'ambiwidth'|
 
 KEY CODES
 Note: Use the <> form if possible
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 7fde2ed..e8604d9 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 7.3.  Last change: 2013 Mar 07
+*todo.txt*      For Vim version 7.3.  Last change: 2013 Mar 18
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -45,38 +45,16 @@
 
 Discussion about canonicalization of Hebrew. (Ron Aaron, 2011 April 10)
 
-Patch to build with Ruby 2.0 and Ming@ 64. (Ken Takata, 2013 Feb 28)
-
 Checking runtime scripts: Thilo Six, 2012 Jun 6.
 
+Patch to keep serving the selection while waiting for a child process.
+(Yukihiro Nakadaira, 2013 March 14)
+
 GTK: problem with 'L' in 'guioptions' changing the window width.
 (Aaron Cornelius, 2012 Feb 6)
 
-Patch for this problem: (David Bürgin (glts), 2013 Mar 5)
-8   ":g//" gives "Pattern not found error" with E486.  Should not use the
-    error number, it's not a regular error message.
-
-Patch to fix ":vimgrep //". (David Bürgin (glts), 2013 Mar 5)
-
-Updates for Debian runtime files. (James McCoy, 2013 Mar 3)
-Also an update for debcontrol in another message.
-
 Javascript file where indent gets stuck on: GalaxyMaster, 2012 May 3.
 
-Patch for ":sort" not properly handling an empty search pattern when there is
-no previous search pattern. (David Bürgin, 2013 Mar 4)
-
-system() breaks clipboard text.  (Yukihiro Nakadaira, 2013 Feb 28)
-Patch by Christian Brabandt, 2013 Mar 1.
-
-Patch for replace multi-byte character in multiple lines. (Yasuhiro Matsumoto,
-2013 Feb 27)
-
-Patch to avoid register being changed when yanking. (Christian Brabandt, 2013
-Feb 26)
-
-Patch to trigger QuitPre in more situations. (Tatsuro Fujii, 2013 Mar 3)
-
 The CompleteDone autocommand needs some info passed to it:
 - The word that was selected (empty if abandoned complete)
 - Type of completion: tag, omnifunc, user func.
@@ -85,21 +63,17 @@
 complete the contents of the directory.  No escaping for the "!"? (Jan
 Stocker, 2012 Jan 5)
 
-Patch to fix wrong completion entry after using backspace. (reported by
-Olivier Teuliere, fixed by Christian Brabandt, 2013 Feb 26)
-
-Patch to detect value of 'ambiwidth' from the termresponse.
-(Hayaki Saito, 2013 Feb 11)
-
 Matchparen does not update match when indenting. (Marc Aldorasi, 2013 Feb 9)
 Possible patch by Christian Brabandt, 2013 Feb 13.
 
+Remarks about the more message and a patch to change behavior. (cptstubing,
+2013 Mar 16)
+
+Patch to set antialiasing style on Windows. (Ondrej Balaz, 2013 Mar 14)
+
 Problem caused by patch 7.3.638: window->open does not update window
 correctly. Issue 91.
 
-Patch for this bug: Setting local value of 'number' resets global value.
-(Markus Heidelberg, 2013 Feb 17)
-
 Patch to add argument to bufname() to only consider buffers in the current
 tab.  (Alexey Radkov, 2013 Feb 8)  Example in later email.
 Is this right?
@@ -135,6 +109,9 @@
 
 New syntax files for apt. (quidame, 2012 Sep 21)
 
+v:register is not directly reset to " after a delete command that specifies a
+register.  It is reset after the next command. (Steve Vermeulen, 2013 Mar 16)
+
 'ff' is wrong for one-line file without EOL. (Issue 77)
 
 Patch for if_lua. (Luis Carvalho, 2012 Aug 26, update Aug 29, another Aug 30,
@@ -178,6 +155,8 @@
 Patch to use directX to draw text on Windows.  Adds the 'directx' option.
 (Taro Muraoka, 2013 Jan 25)
 
+Problem with refresh:always in completion. (Tyler Wade, 2013 Mar 17)
+
 b:undo_ftplugin cannot call a script-local function. (Boris Danilov, 2013 Jan
 7)
 
@@ -271,9 +250,6 @@
     More recent version: https://retracile.net/wiki/VimBreakIndent
     Posted to vim-dev by Taylor Hedberg, 2011 Nov 25
 
-Problem with starting Visual block mode with :norm when 'virtualedit' is set.
-(David glts, 2012 Jun 5)
-
 ":cd" doesn't work when current directory path contains "**".
 finddir() has the same problem.  (Yukihiro Nakadaira, 2012 Jan 10)
 Requires a rewrite of the file_file_in_path code.
@@ -286,9 +262,6 @@
 
 Issue 48: foldopen error can't be caught by try/catch
 
-"dg_" deletes including the last character, "d:normal! g_" doesn't.
-(Nomen Nescio, 2012 Jun 27)
-
 Patch to sort functions starting with '<' after others.  Omit dict functions,
 they can't be called. (Yasuhiro Matsumoto, 2011 Oct 11)
 
