diff --git a/runtime/doc/index.txt b/runtime/doc/index.txt
index c2b1ca1..43196e9 100644
--- a/runtime/doc/index.txt
+++ b/runtime/doc/index.txt
@@ -1,4 +1,4 @@
-*index.txt*     For Vim version 7.3.  Last change: 2013 Jun 06
+*index.txt*     For Vim version 7.3.  Last change: 2013 Jun 21
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -801,6 +801,10 @@
 |zE|		zE		   eliminate all folds
 |zF|		zF		   create a fold for N lines
 |zG|		zG		   mark word as good spelled word
+|zH|		zH		   when 'wrap' off scroll half a screenwidth
+				   to the right
+|zL|		zL		   when 'wrap' off scroll half a screenwidth
+				   to the left
 |zM|		zM		   set 'foldlevel' to zero
 |zN|		zN		   set 'foldenable'
 |zO|		zO		   open folds recursively
diff --git a/runtime/doc/intro.txt b/runtime/doc/intro.txt
index 856726a..402f5a9 100644
--- a/runtime/doc/intro.txt
+++ b/runtime/doc/intro.txt
@@ -1,4 +1,4 @@
-*intro.txt*     For Vim version 7.3.  Last change: 2012 Sep 05
+*intro.txt*     For Vim version 7.3.  Last change: 2013 Jun 17
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -261,6 +261,7 @@
 I wish to thank all the people that sent me bug reports and suggestions.  The
 list is too long to mention them all here.  Vim would not be the same without
 the ideas from all these people: They keep Vim alive!
+*love* *peace* *friendship* *gross-national-happiness*
 
 
 In this documentation there are several references to other versions of Vi:
diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index 3779de1..ac62216 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 Jun 06
+*syntax.txt*	For Vim version 7.3.  Last change: 2013 Jun 24
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -1318,8 +1318,8 @@
 
 Default highlighting and dialect ~
 Highlighting appropriate for Fortran 2008 is used by default.  This choice
-should be appropriate for most users most of the time because Fortran 2008 is 
-almost a superset of previous versions (Fortran 2003, 95, 90, and 77). 
+should be appropriate for most users most of the time because Fortran 2008 is
+almost a superset of previous versions (Fortran 2003, 95, 90, and 77).
 
 Fortran source code form ~
 Fortran code can be in either fixed or free source form.  Note that the
@@ -1410,7 +1410,7 @@
 
 If you use F, the advantage of setting the dialect appropriately is that
 other legacy features excluded from F will be highlighted as todo items and
-that free source form will be assumed. 
+that free source form will be assumed.
 
 The dialect can be selected in various ways.  If all your fortran files use
 the same dialect, set the global variable fortran_dialect in your .vimrc prior
@@ -1444,13 +1444,13 @@
 For previous versions of the syntax, you may have set fortran_dialect to the
 now-obsolete values "f77", "f90", "f95", or "elf". Such settings will be
 silently handled as "f08". Users of "elf" may wish to experiment with "F"
-instead. 
+instead.
 
 The syntax/fortran.vim script contains embedded comments that tell you how to
 comment and/or uncomment some lines to (a) activate recognition of some
 non-standard, vendor-supplied intrinsics and (b) to prevent features deleted
 or declared obsolescent in the 2008 standard from being highlighted as todo
-items. 
+items.
 
 Limitations ~
 Parenthesis checking does not catch too few closing parentheses.  Hollerith
@@ -2197,9 +2197,11 @@
 
 There are a number of possible options to the perl syntax highlighting.
 
-If you use POD files or POD segments, you might: >
+Inline POD highlighting is now turned on by default.  If you don't wish
+to have the added complexity of highlighting POD embedded within Perl
+files, you may set the 'perl_include_pod' option to 0: >
 
-	:let perl_include_pod = 1
+	:let perl_include_pod = 0
 
 The reduce the complexity of parsing (and increase performance) you can switch
 off two elements in the parsing of variable names and contents. >
@@ -2252,13 +2254,20 @@
 
 	:let perl_fold_blocks = 1
 
-To avoid folding packages or subs when perl_fold is let, let the appropriate
-variable(s): >
+Subroutines are folded by default if 'perl_fold' is set.  If you do not want
+this, you can set 'perl_nofold_subs': >
 
-	:unlet perl_nofold_packages
-	:unlet perl_nofold_subs
+	:let perl_nofold_subs = 1
 
+Anonymous subroutines are not folded by default; you may enable their folding
+via 'perl_fold_anonymous_subs': >
 
+	:let perl_fold_anonymous_subs = 1
+
+Packages are also folded by default if 'perl_fold' is set.  To disable this
+behavior, set 'perl_nofold_packages': >
+
+	:let perl_nofold_packages = 1
 
 PHP3 and PHP4		*php.vim* *php3.vim* *ft-php-syntax* *ft-php3-syntax*
 
@@ -2481,7 +2490,7 @@
 preceding last option and unsetting all other ones): >
 	:let python_highlight_all = 1
 
-Note: only existence of these options matter, not their value. You can replace 
+Note: only existence of these options matter, not their value. You can replace
       1 above with anything.
 
 
@@ -2874,9 +2883,24 @@
 redrawing can become slow.
 
 
-TEX						*tex.vim* *ft-tex-syntax*
+TEX				*tex.vim* *ft-tex-syntax* *latex-syntax*
 
-								*tex-folding*
+			Tex Contents~
+	Tex: Want Syntax Folding?			|tex-folding|
+	Tex: No Spell Checking Wanted			|g:tex_nospell|
+	Tex: Don't Want Spell Checking In Comments?	|tex-nospell|
+	Tex: Want Spell Checking in Verbatim Zones?	|tex-verb|
+	Tex: Run-on Comments or MathZones		|tex-runon|
+	Tex: Slow Syntax Highlighting?			|tex-slow|
+	Tex: Want To Highlight More Commands?		|tex-morecommands|
+	Tex: Excessive Error Highlighting?		|tex-error|
+	Tex: Need a new Math Group?			|tex-math|
+	Tex: Starting a New Style?			|tex-style|
+	Tex: Taking Advantage of Conceal Mode		|tex-conceal|
+	Tex: Selective Conceal Mode			|g:tex_conceal|
+	Tex: Controlling iskeyword			|g:tex_isk|
+
+				*tex-folding* *g:tex_fold_enabled*
  Tex: Want Syntax Folding? ~
 
 As of version 28 of <syntax/tex.vim>, syntax-based folding of parts, chapters,
@@ -2886,24 +2910,27 @@
 modeline at the end of your LaTeX file: >
 	% vim: fdm=syntax
 If your system becomes too slow, then you might wish to look into >
- 	http://vim.wikia.com/wiki/Keep_folds_closed_while_inserting_text
+	https://vimhelp.appspot.com/vim_faq.txt.html#faq-29.7
 <
-								*tex-nospell*
+						*g:tex_nospell*
+ Tex: No Spell Checking Wanted~
+
+If you don't want spell checking anywhere in your LaTeX document, put >
+	let g:tex_nospell=1
+into your .vimrc.  If you merely wish to suppress spell checking inside
+comments only, see |g:tex_comment_nospell|.
+
+				*tex-nospell* *g:tex_comment_nospell*
  Tex: Don't Want Spell Checking In Comments? ~
 
 Some folks like to include things like source code in comments and so would
 prefer that spell checking be disabled in comments in LaTeX files.  To do
 this, put the following in your <.vimrc>: >
       let g:tex_comment_nospell= 1
-The comment lines >
-	% nospell{
-	...
-	% nospell}
-will suppress spell checking between them.  These comment lines spelling
-control are known to be fragile; for example, don't include any of the section
-commands (\part, \chapter, \section, \paragraph, etc) inside nospell blocks
-or interleave environments (such as math) across nospell blocks.
-								*tex-verb*
+If you want to suppress spell checking everywhere inside your LaTeX document,
+see |g:tex_nospell|.
+
+				*tex-verb* *g:tex_verbspell*
  Tex: Want Spell Checking in Verbatim Zones?~
 
 Often verbatim regions are used for things like source code; seldom does
@@ -2911,7 +2938,7 @@
 want your verbatim zones spell-checked, put the following in your <.vimrc>: >
 	let g:tex_verbspell= 1
 <
-								*tex-runon*
+					*tex-runon* *tex-stopzone*
  Tex: Run-on Comments or MathZones ~
 
 The <syntax/tex.vim> highlighting supports TeX, LaTeX, and some AmsTeX.  The
@@ -2924,7 +2951,7 @@
 which will forcibly terminate the highlighting of either a texZone or a
 texMathZone.
 
-								*tex-slow*
+					*tex-slow* *tex-sync*
  Tex: Slow Syntax Highlighting? ~
 
 If you have a slow computer, you may wish to reduce the values for >
@@ -2966,7 +2993,39 @@
 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*
+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? ~
 
 LaTeX is a programmable language, and so there are thousands of packages full
@@ -2978,14 +3037,14 @@
 which typically would go in $HOME/after/syntax/tex/[pkgname].vim, to
 http://vim.sf.net/.
 
-								*tex-error*
+					*tex-error* *g:tex_no_error*
  Tex: Excessive Error Highlighting? ~
 
 The <tex.vim> supports lexical error checking of various sorts.  Thus,
 although the error checking is ofttimes very useful, it can indicate
 errors where none actually are.  If this proves to be a problem for you,
 you may put in your <.vimrc> the following statement: >
-	let tex_no_error=1
+	let g:tex_no_error=1
 and all error checking by <syntax/tex.vim> will be suppressed.
 
 								*tex-math*
@@ -3003,7 +3062,7 @@
 The "starform" variable, if true, implies that your new math group
 has a starred form (ie. eqnarray*).
 
-								*tex-style*
+					*tex-style* *b:tex_stylish*
  Tex: Starting a New Style? ~
 
 One may use "\makeatletter" in *.tex files, thereby making the use of "@" in
@@ -3030,12 +3089,12 @@
 One way to use this is to have vertically split windows (see |CTRL-W_v|); one
 with |'conceallevel'| at 0 and the other at 2; and both using |'scrollbind'|.
 
-							*g:tex_conceal*
+					*g:tex_conceal*
  Tex: Selective Conceal Mode~
 
 You may selectively use conceal mode by setting g:tex_conceal in your
-<.vimrc>.  By default it is set to "admgs" to enable conceal for the
-following sets of characters: >
+<.vimrc>.  By default, g:tex_conceal is set to "admgs" to enable concealment
+for the following sets of characters: >
 
 	a = accents/ligatures
 	b = bold and italic
@@ -3058,7 +3117,7 @@
 However, one may override this iskeyword re-setting by setting the
 variable, g:tex_isk, in one's .vimrc to whatever one wishes and
 it will be used instead.
- 
+
 
 TF						*tf.vim* *ft-tf-syntax*
 
@@ -3069,6 +3128,26 @@
 
 	:let tf_minlines = your choice
 
+						*g:tex_isk* *g:tex_stylish*
+ Tex: Controlling iskeyword~
+
+Normally, LaTeX keywords support 0-9, a-z, A-z, and 192-255 only. Latex
+keywords don't support the underscore - except when in *.sty files.  The
+syntax highlighting script handles this with the following logic:
+
+	* If g:tex_stylish exists and is 1
+		then the file will be treated as a "sty" file, so the "_"
+		will be allowed as part of keywords
+		(irregardless of g:tex_isk)
+	* Else if the file's suffix is sty, cls, clo, dtx, or ltx,
+		then the file will be treated as a "sty" file, so the "_"
+		will be allowed as part of keywords
+		(irregardless of g:tex_isk)
+
+	* If g:tex_isk exists, then it will be used for the local 'iskeyword'
+	* Else the local 'iskeyword' will be set to 48-57,a-z,A-Z,192-255
+
+
 
 VIM			*vim.vim*		*ft-vim-syntax*
 			*g:vimsyn_minlines*	*g:vimsyn_maxlines*
@@ -4936,7 +5015,7 @@
 "w:current_syntax".
 
 Once a window has its own syntax, syntax commands executed from other windows
-on the same buffer (including :syntax clear) have no effect. Conversely, 
+on the same buffer (including :syntax clear) have no effect. Conversely,
 syntax commands executed from that window do not affect other windows on the
 same buffer.
 
@@ -5141,9 +5220,9 @@
 all positions in the current and previous line.  For example, if the item is
 literal text specify the size of that text (in bytes):
 
-"<\@<=span"   	Matches "span" in "<span".  This tries matching with "<" in
+"<\@<=span"	Matches "span" in "<span".  This tries matching with "<" in
 		many places.
-"<\@1<=span"  	Matches the same, but only tries one byte before "span".
+"<\@1<=span"	Matches the same, but only tries one byte before "span".
 
 
  vim:tw=78:sw=4:ts=8:ft=help:norl:
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 2ebdf3b..2f56ace 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -4808,6 +4808,7 @@
 b:changelog_name	filetype.txt	/*b:changelog_name*
 b:current_syntax-variable	syntax.txt	/*b:current_syntax-variable*
 b:netrw_lastfile	pi_netrw.txt	/*b:netrw_lastfile*
+b:tex_stylish	syntax.txt	/*b:tex_stylish*
 b:var	eval.txt	/*b:var*
 baan-folding	syntax.txt	/*baan-folding*
 baan-syntax	syntax.txt	/*baan-syntax*
@@ -5665,6 +5666,7 @@
 formatting	change.txt	/*formatting*
 formfeed	intro.txt	/*formfeed*
 fortran.vim	syntax.txt	/*fortran.vim*
+friendship	intro.txt	/*friendship*
 frombook	usr_01.txt	/*frombook*
 ft-abel-syntax	syntax.txt	/*ft-abel-syntax*
 ft-ada-commands	ft_ada.txt	/*ft-ada-commands*
@@ -5997,10 +5999,18 @@
 g:tar_readoptions	pi_tar.txt	/*g:tar_readoptions*
 g:tar_secure	pi_tar.txt	/*g:tar_secure*
 g:tar_writeoptions	pi_tar.txt	/*g:tar_writeoptions*
+g:tex_comment_nospell	syntax.txt	/*g:tex_comment_nospell*
 g:tex_conceal	syntax.txt	/*g:tex_conceal*
 g:tex_fast	syntax.txt	/*g:tex_fast*
+g:tex_fast	syntax.txt	/*g:tex_fast*
 g:tex_flavor	filetype.txt	/*g:tex_flavor*
+g:tex_fold_enabled	syntax.txt	/*g:tex_fold_enabled*
 g:tex_isk	syntax.txt	/*g:tex_isk*
+g:tex_isk	syntax.txt	/*g:tex_isk*
+g:tex_no_error	syntax.txt	/*g:tex_no_error*
+g:tex_nospell	syntax.txt	/*g:tex_nospell*
+g:tex_stylish	syntax.txt	/*g:tex_stylish*
+g:tex_verbspell	syntax.txt	/*g:tex_verbspell*
 g:var	eval.txt	/*g:var*
 g:vimball_home	pi_vimball.txt	/*g:vimball_home*
 g:vimball_mkdir	pi_vimball.txt	/*g:vimball_mkdir*
@@ -6134,6 +6144,7 @@
 greek	options.txt	/*greek*
 grep	quickfix.txt	/*grep*
 groff.vim	syntax.txt	/*groff.vim*
+gross-national-happiness	intro.txt	/*gross-national-happiness*
 group-name	syntax.txt	/*group-name*
 gs	various.txt	/*gs*
 gsp.vim	syntax.txt	/*gsp.vim*
@@ -6614,6 +6625,7 @@
 last-pattern	pattern.txt	/*last-pattern*
 last-position-jump	eval.txt	/*last-position-jump*
 last_buffer_nr()	eval.txt	/*last_buffer_nr()*
+latex-syntax	syntax.txt	/*latex-syntax*
 lc_time-variable	eval.txt	/*lc_time-variable*
 lcs-conceal	options.txt	/*lcs-conceal*
 lcs-eol	options.txt	/*lcs-eol*
@@ -6667,6 +6679,7 @@
 log()	eval.txt	/*log()*
 log10()	eval.txt	/*log10()*
 long-lines	version5.txt	/*long-lines*
+love	intro.txt	/*love*
 lowercase	change.txt	/*lowercase*
 lpc.vim	syntax.txt	/*lpc.vim*
 lua	if_lua.txt	/*lua*
@@ -7244,6 +7257,7 @@
 pattern.txt	pattern.txt	/*pattern.txt*
 patterns-composing	pattern.txt	/*patterns-composing*
 pdev-option	print.txt	/*pdev-option*
+peace	intro.txt	/*peace*
 penc-option	print.txt	/*penc-option*
 perl	if_perl.txt	/*perl*
 perl-Append	if_perl.txt	/*perl-Append*
@@ -8186,7 +8200,9 @@
 tex-package	syntax.txt	/*tex-package*
 tex-runon	syntax.txt	/*tex-runon*
 tex-slow	syntax.txt	/*tex-slow*
+tex-stopzone	syntax.txt	/*tex-stopzone*
 tex-style	syntax.txt	/*tex-style*
+tex-sync	syntax.txt	/*tex-sync*
 tex-verb	syntax.txt	/*tex-verb*
 tex.vim	syntax.txt	/*tex.vim*
 text-functions	usr_41.txt	/*text-functions*
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 5e38724..504f427 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 Jun 15
+*todo.txt*      For Vim version 7.3.  Last change: 2013 Jun 24
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -36,6 +36,9 @@
 
 --- Python interface
 
+Test 86 fails on MS-Windows. (Taro Muraoka, 2013 Jun 24)
+Can we fix this in code instead of in the test?
+
 Python: ":py raw_input('prompt')" doesn't work. (Manu Hack)
 
 Win32: The Python interface only works with one version of Python, selected at
@@ -51,22 +54,20 @@
 
 --- bug fixes
 
-Do allow real tags above the !_TAG entries. Undo older patch. Issue 90.
-
-Matches might be highlighted correctly. Inefficient patch by Christian
-Brabandt, 2013 Feb 26.
-
-Patch to use bold/italic fonts when 'guifontewide' is set. (Ken Takata, 2013
-Mar 31)
-
 Problem with winfixheight and resizing. (Yukihiro Nakadaira, 2011 Sep 17)
 Patch Sep 18.
 
 Patch for IME problems. Remove hacking code for old IM. (Yukihiro Nakadaira,
 2012 Jul 20)
 
+Modeline is not triggered when using Vim: instead of vim:. It's very hard to
+see why it doesn't work.
+
 Patch to fix finding toolbar bitmaps.  Issue 129.
 
+Patch to avoid clang warnings when building with Athena.
+(Dominique Pelle, 2013 Jun 22)
+
 Suggestion to remove __QNXNTO__ in gui.c. (Sean Boudreau, 2013 Jun 7)
 
 Combining characters are not used when executing a register with :@w.
@@ -106,6 +107,9 @@
 Patch to fix glob() and globpath() with escaped special characters.
 (Adnan Zafar, 2013 Jun 2, tests Jun 3)
 
+Bug in findfile() directory matching. (Markus Braun Ben Fritz, 2013 Jun 20)
+Patch by Christian Brabandt (2013 Jun 22)
+
 ---- Fixes to be included before 7.4 above, less important stuff below ----
 
 Patch to make has() check for Vim version and patch at the same time.
@@ -158,6 +162,9 @@
 Patch to invert characters differently in GTK. (Yukihiro Nakadaira, 2013 May
 5)
 
+Patch to add "Q" and "A" responses to interactive :substitute. They are
+carried over when using :global. (Christian Brabandt, 2013 Jun 19)
+
 Bug with 'cursorline' in diff mode.  Line being scrolled into view gets
 highlighted as the cursor line.  (Alessandro Ivaldi, 2013 Jun 4)
 
@@ -195,6 +202,10 @@
 
 'ff' is wrong for one-line file without EOL. (Issue 77)
 
+Can add a function to a dict using a weird key:
+    let dict['/foo'] = function('tr')
+Disallow? (thinca, 2013 Jun 17)
+
 Patch to set antialiasing style on Windows. (Ondrej Balaz, 2013 Mar 14)
 Needs a different check for CLEARTYPE_QUALITY.
 
@@ -268,6 +279,8 @@
 Patch to append regexp to tag commands to make it possible to select one out
 of many matches. (Cody Cutler, 2013 Mar 28)
 
+Patch to add tagfunc().  Cleaned up by Christian Brabandt, 2013 Jun 22.
+
 Help for 'b:undo_indent'. (Thilo Six, 2012 May 28)
 Also question if examples are correct.
 
