diff --git a/runtime/autoload/xmlformat.vim b/runtime/autoload/xmlformat.vim
index b21eccd..83ba49a 100644
--- a/runtime/autoload/xmlformat.vim
+++ b/runtime/autoload/xmlformat.vim
@@ -1,5 +1,5 @@
 " Vim plugin for formatting XML
-" Last Change: Thu, 15 Jan 2015 21:26:55 +0100
+" Last Change: Thu, 22 May 2018 21:26:55 +0100
 " Version: 0.1
 " Author: Christian Brabandt <cb@256bit.org>
 " Script:  http://www.vim.org/scripts/script.php?script_id=
@@ -30,7 +30,7 @@
   let lastitem = prev ? getline(prev) : ''
   let is_xml_decl = 0
   " split on `<`, but don't split on very first opening <
-  for item in split(getline(v:lnum), '.\@<=[>]\zs')
+  for item in split(join(getline(v:lnum, (v:lnum + v:count - 1))), '.\@<=[>]\zs')
     if s:EndTag(item)
       let s:indent = s:DecreaseIndent()
       call add(result, s:Indent(item))
diff --git a/runtime/colors/tools/check_colors.vim b/runtime/colors/tools/check_colors.vim
index 0cfe5ec..6c5e8f3 100644
--- a/runtime/colors/tools/check_colors.vim
+++ b/runtime/colors/tools/check_colors.vim
@@ -1,5 +1,5 @@
 " This script tests a color scheme for some errors. Load the scheme and source
-" this script. e.g. :e colors/desert.vim | :so test_colors.vim
+" this script. e.g. :e colors/desert.vim | :so check_colors.vim
 " Will output possible errors.
 
 let s:save_cpo= &cpo
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 905074c..e243ba3 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -5822,7 +5822,8 @@
 		listing.
 
 		When there is no mapping for {name}, an empty String is
-		returned.
+		returned.  When the mapping for {name} is empty, then "<Nop>"
+		is returned.
 
 		The {name} can have special key names, like in the ":map"
 		command.
@@ -5889,9 +5890,10 @@
 		mapping that matches with {name}, while maparg() only finds a
 		mapping for {name} exactly.
 		When there is no mapping that starts with {name}, an empty
-		String is returned.  If there is one, the rhs of that mapping
+		String is returned.  If there is one, the RHS of that mapping
 		is returned.  If there are several mappings that start with
-		{name}, the rhs of one of them is returned.
+		{name}, the RHS of one of them is returned.  This will be
+		"<Nop>" if the RHS is empty.
 		The mappings local to the current buffer are checked first,
 		then the global mappings.
 		This function can be used to check if a mapping can be added
diff --git a/runtime/doc/gui.txt b/runtime/doc/gui.txt
index a66d997..c30aa33 100644
--- a/runtime/doc/gui.txt
+++ b/runtime/doc/gui.txt
@@ -999,7 +999,7 @@
 				pointer instead of the cursor.
 				In the terminal this is the last known
 				position, which is usually at the last click
-				or release (mouse movement is irrelevalt).
+				or release (mouse movement is irrelevant).
 
 Example: >
 	:popup File
diff --git a/runtime/doc/indent.txt b/runtime/doc/indent.txt
index ac8bf53..180d932 100644
--- a/runtime/doc/indent.txt
+++ b/runtime/doc/indent.txt
@@ -907,6 +907,25 @@
 and 'default:' are indented at the same level than the 'switch()' to avoid
 meaningless indentation. You can use the above option to return to the
 traditional way.
+-------------
+
+							*PHP_noArrowMatching*
+By default the indent script will indent multi-line chained calls by matching
+the position of the '->': >
+
+    $user_name_very_long->name()
+                        ->age()
+                        ->info();
+
+You can revert to the classic way of indenting by setting this option to 1: >
+    :let g:PHP_noArrowMatching = 1
+
+You will obtain the following result: >
+
+    $user_name_very_long->name()
+        ->age()
+        ->info();
+
 
 
 PYTHON							*ft-python-indent*
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 01c2d0e..422f100 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -5187,7 +5187,7 @@
 	more depth, set 'maxfuncdepth' to a bigger number.  But this will use
 	more memory, there is the danger of failing when memory is exhausted.
 	Increasing this limit above 200 also changes the maximum for Ex
-	command resursion, see |E169|.
+	command recursion, see |E169|.
 	See also |:function|.
 
 						*'maxmapdepth'* *'mmd'* *E223*
diff --git a/runtime/doc/tabpage.txt b/runtime/doc/tabpage.txt
index 20dd1ef..31fcc43 100644
--- a/runtime/doc/tabpage.txt
+++ b/runtime/doc/tabpage.txt
@@ -213,7 +213,8 @@
 :tabN[ext] {count}
 {count}<C-PageUp>
 {count}gT	Go {count} tab pages back.  Wraps around from the first one
-		to the last one.
+		to the last one.  Note that the use of {count} is different
+		from |:tabnext|, where it is used as the tab page number.
 
 :tabr[ewind]			*:tabfir* *:tabfirst* *:tabr* *:tabrewind*
 :tabfir[st]	Go to the first tab page.
diff --git a/runtime/doc/tags b/runtime/doc/tags
index ea0b252..9d5af7f 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -4749,6 +4749,7 @@
 PHP_BracesAtCodeLevel	indent.txt	/*PHP_BracesAtCodeLevel*
 PHP_autoformatcomment	indent.txt	/*PHP_autoformatcomment*
 PHP_default_indenting	indent.txt	/*PHP_default_indenting*
+PHP_noArrowMatching	indent.txt	/*PHP_noArrowMatching*
 PHP_outdentSLComments	indent.txt	/*PHP_outdentSLComments*
 PHP_outdentphpescape	indent.txt	/*PHP_outdentphpescape*
 PHP_removeCRwhenUnix	indent.txt	/*PHP_removeCRwhenUnix*
@@ -8198,6 +8199,8 @@
 ref	intro.txt	/*ref*
 reference	intro.txt	/*reference*
 reference_toc	help.txt	/*reference_toc*
+reg_executing()	eval.txt	/*reg_executing()*
+reg_recording()	eval.txt	/*reg_recording()*
 regexp	pattern.txt	/*regexp*
 regexp-changes-5.4	version5.txt	/*regexp-changes-5.4*
 register	sponsor.txt	/*register*
diff --git a/runtime/doc/terminal.txt b/runtime/doc/terminal.txt
index 8b8b77c..b3fe522 100644
--- a/runtime/doc/terminal.txt
+++ b/runtime/doc/terminal.txt
@@ -204,7 +204,7 @@
 			++rows={height} Use {height} for the terminal window
 					height.  If the terminal uses the full
 					Vim height (no window above or below
-					th terminal window) the command line
+					the terminal window) the command line
 					height will be reduced as needed.
 			++cols={width}  Use {width} for the terminal window
 					width. If the terminal uses the full
@@ -243,7 +243,7 @@
 You can use `CTRL-W :hide` to close the terminal window and make the buffer
 hidden, the job keeps running.  The `:buffer` command can be used to turn the
 current window into a terminal window.  If there are unsaved changes this
-fails, use !  to force, as usual.
+fails, use ! to force, as usual.
 
 To have a background job run without a window, and open the window when it's
 done, use options like this: >
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 13ab355..2029c35 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -39,7 +39,7 @@
 -------------------- Known bugs and current work -----------------------
 
 Terminal emulator window:
-- Win32: Termdebug doesn't work, because gdb does not support mi2.
+- Win32: Termdebug doesn't work, because gdb does not support mi2 on a tty.
   This plugin: https://github.com/cpiger/NeoDebug  runs gdb as a job,
   redirecting input and output.
   Open new console for for program with: "set new-console on"
@@ -61,13 +61,13 @@
   after "run".  Everything else works, including communication channel.  Not
   initializing mzscheme avoid the problem, thus it's not some #ifdef.
 
-Patch to refactor efm_to_regpat(). (Yegappan Lakshmanan, 2018 May 16, #2924)
+Does not build with MinGW out of the box:
+- _stat64 is not defined, need to use "struct stat" in vim.h
+- WINVER conflict, should use 0x0600 by default?
 
 Crash when mixing matchadd and substitute()? (Max Christian Pohle, 2018 May
 13, #2910)  Can't reproduce?
 
-Deprecate using  has("patch213")  always include the version number.
-
 On Win32 when not in the console and t_Co >= 256, allow using 'tgc'.
 (Nobuhiro Takasaki, #2833)  Also check t_Co.
 
@@ -123,11 +123,8 @@
 Should add a test for every command line argument.  Check coverage for what is
 missing: --nofork, -A , -b, -h, etc.
 
-Completing a command sometimes results in duplicates, since 7.4.672.
-(Yegappan Lakshmanan, 2018 May 16)
-Duplication of completion suggestions for ":!hom".  Issue #539.
-Patch by Christian, 2016 Jan 29
-Another patch in #2733.
+Patch for variable tabstops.  On github (Christian Brabandt, 2014 May 15)
+Update 2018 March 12, #2711
 
 Improve the installer for MS-Windows.  There are a few alternatives:
 - Add silent install option. (Shane Lee, #751)
@@ -152,6 +149,7 @@
 with packages under "start". (xtal8, #1994)
 
 Patch to support "xxd -ps". (Erik Auerswald, 2018 May 1)
+Lacks a test.
 
 Column number is wrong when using 'linebreak' and 'wrap'. (Keith Smiley, 2018
 Jan 15, #2555)
@@ -160,8 +158,6 @@
 
 Check argument of systemlist(). (Pavlov)
 
-Patch to add reg_executing() and reg_recording(). (Hirohito Higashi, #2745)
-
 No maintainer for Vietnamese translations.
 No maintainer for Simplified Chinese translations.
 
@@ -1184,9 +1180,6 @@
 Patch: On MS-Windows shellescape() may have to triple double quotes.
 (Ingo Karkat, 2015 Jan 16)
 
-Patch for variable tabstops.  On github (Christian Brabandt, 2014 May 15)
-Update 2018 March 12, #2711
-
 Redo only remembers the last change.  Could use "{count}g." to redo an older
 change.  How does the user know which change?  At least have a way to list
 them: ":repeats".
diff --git a/runtime/doc/version8.txt b/runtime/doc/version8.txt
index c091063..d927c54 100644
--- a/runtime/doc/version8.txt
+++ b/runtime/doc/version8.txt
@@ -14549,12 +14549,37 @@
 Internal: A few C99 features are now allowed such as // comments and a
 comma after the last enum entry.  See |style-compiler|.
 
+Since patch 8.0.0029 removed support for older MS-Windows systems, only
+MS-Windows XP and later are supported.
+
 
 Added							*added-8.1*
 -----
 
 Various syntax, indent and other plugins were added.
 
+Quickfix improvements (by Yegappan Lakshmanan):
+	Added support for modifying any quickfix/location list in the quickfix
+	stack.
+	Added a unique identifier for every quickfix/location list.
+	Added support for associating any Vim type as a context information to
+	a quickfix/location list.
+	Enhanced the getqflist(), getloclist(), setqflist() and setloclist()
+	functions to get and set the various quickfix/location list attributes.
+	Added the QuickFixLine highlight group to highlight the current line
+	in the quickfix window.
+	The quickfix buffer b:changedtick variable is incremented for every
+	change to the contained quickfix list.
+	Added a changedtick variable to a quickfix/location list which is
+	incremented when the list is modified.
+	Added support for parsing text using 'errorformat' without creating a
+	new quickfix list.
+	Added support for the "module" item to a quickfix entry which can be
+	used for display purposes instead of a long file name.
+	Added support for freeing all the lists in the quickfix/location stack.
+	When opening a quickfix window using the :copen/:cwindow commands, the
+	supplied split modifiers are used.
+
 Functions:
 	All the term_ functions.
 
@@ -21591,7 +21616,7 @@
 
 Patch 8.0.1158
 Problem:    Still old style tests.
-Solution:   Convert serveral tests to new style. (Yegappan Lakshmanan)
+Solution:   Convert several tests to new style. (Yegappan Lakshmanan)
 Files:      src/Makefile, src/testdir/Make_all.mak, src/testdir/Make_vms.mms,
             src/testdir/main.aap, src/testdir/test33.in,
             src/testdir/test33.ok, src/testdir/test41.in,
diff --git a/runtime/indent/php.vim b/runtime/indent/php.vim
index d13a0a1..5dee6c9 100644
--- a/runtime/indent/php.vim
+++ b/runtime/indent/php.vim
@@ -3,8 +3,8 @@
 " Author:	John Wellesz <John.wellesz (AT) teaser (DOT) fr>
 " URL:		http://www.2072productions.com/vim/indent/php.vim
 " Home:		https://github.com/2072/PHP-Indenting-for-VIm
-" Last Change:	2018 May 14
-" Version:	1.62
+" Last Change:	2018 May 18th
+" Version:	1.66
 "
 "
 "	Type :help php-indent for available options
@@ -82,6 +82,12 @@
     let b:PHP_outdentphpescape = 1
 endif
 
+if exists("PHP_noArrowMatching")
+    let b:PHP_noArrowMatching = PHP_noArrowMatching
+else
+    let b:PHP_noArrowMatching = 0
+endif
+
 
 if exists("PHP_vintage_case_default_indent") && PHP_vintage_case_default_indent
     let b:PHP_vintage_case_default_indent = 1
@@ -130,7 +136,7 @@
 let s:PHP_validVariable = '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
 let s:notPhpHereDoc = '\%(break\|return\|continue\|exit\|die\|else\)'
 let s:blockstart = '\%(\%(\%(}\s*\)\=else\%(\s\+\)\=\)\=if\>\|\%(}\s*\)\?else\>\|do\>\|while\>\|switch\>\|case\>\|default\>\|for\%(each\)\=\>\|declare\>\|class\>\|trait\>\|use\>\|interface\>\|abstract\>\|final\>\|try\>\|\%(}\s*\)\=catch\>\|\%(}\s*\)\=finally\>\)'
-let s:functionDecl = '\<function\>\%(\s\+'.s:PHP_validVariable.'\)\=\s*(.*'
+let s:functionDecl = '\<function\>\%(\s\+&\='.s:PHP_validVariable.'\)\=\s*(.*'
 let s:endline = '\s*\%(//.*\|#.*\|/\*.*\*/\s*\)\=$'
 let s:unstated = '\%(^\s*'.s:blockstart.'.*)\|\%(//.*\)\@<!\<e'.'lse\>\)'.s:endline
 
@@ -140,7 +146,6 @@
 let s:structureHead = '^\s*\%(' . s:blockstart . '\)\|'. s:functionDecl . s:endline . '\|\<new\s\+class\>'
 
 
-
 let s:escapeDebugStops = 0
 function! DebugPrintReturn(scriptLine)
 
@@ -257,7 +262,7 @@
 
 function! Skippmatch()	" {{{
     let synname = synIDattr(synID(line("."), col("."), 0), "name")
-    if synname == "Delimiter" || synname == "phpRegionDelimiter" || synname =~# "^phpParent" || synname == "phpArrayParens" || synname =~# '^php\%(Block\|Brace\)' || synname == "javaScriptBraces" || synname =~# '^php\%(Doc\)\?Comment' && b:UserIsTypingComment
+    if synname ==? "Delimiter" || synname ==? "phpRegionDelimiter" || synname =~? "^phpParent" || synname ==? "phpArrayParens" || synname =~? '^php\%(Block\|Brace\)' || synname ==? "javaScriptBraces" || synname =~? '^php\%(Doc\)\?Comment' && b:UserIsTypingComment
 	return 0
     else
 	return 1
@@ -297,6 +302,48 @@
     return balance
 endfun
 
+function! StripEndlineComments (line)
+    return substitute(a:line,"\\(//\\|#\\)\\(\\(\\([^\"']*\\([\"']\\)[^\"']*\\5\\)\\+[^\"']*$\\)\\|\\([^\"']*$\\)\\)",'','')
+endfun
+
+function! FindArrowIndent (lnum)  " {{{
+
+    let parrentArrowPos = 0
+    let lnum = a:lnum
+    while lnum > 1
+	let last_line = getline(lnum)
+	if last_line =~ '^\s*->'
+	    let parrentArrowPos = indent(a:lnum)
+	    break
+	else
+	    call cursor(lnum, 1)
+	    let cleanedLnum = StripEndlineComments(last_line)
+	    if cleanedLnum =~ '->'
+		if ! b:PHP_noArrowMatching
+		    let parrentArrowPos = searchpos('->', 'W', lnum)[1] - 1
+		else
+		    let parrentArrowPos = indent(lnum) + shiftwidth()
+		endif
+		break
+	    elseif cleanedLnum =~ ')'.s:endline && BalanceDirection(last_line) < 0
+		call searchpos(')'.s:endline, 'cW', lnum)
+		let openedparent = searchpair('(', '', ')', 'bW', 'Skippmatch()')
+		if openedparent != lnum
+		    let lnum = openedparent
+		else
+		    let openedparent = -1
+		endif
+
+	    else
+		let parrentArrowPos = indent(lnum) + shiftwidth()
+		break
+	    endif
+	endif
+    endwhile
+
+    return parrentArrowPos
+endfun "}}}
+
 function! FindTheIfOfAnElse (lnum, StopAfterFirstPrevElse) " {{{
 
     if getline(a:lnum) =~# '^\s*}\s*else\%(if\)\=\>'
@@ -368,7 +415,7 @@
 
 endfunction "}}}
 
-let s:SynPHPMatchGroups = {'phpParent':1, 'Delimiter':1, 'Define':1, 'Storageclass':1, 'StorageClass':1, 'Structure':1, 'Exception':1}
+let s:SynPHPMatchGroups = {'phpparent':1, 'delimiter':1, 'define':1, 'storageclass':1, 'structure':1, 'exception':1}
 function! IslinePHP (lnum, tofind) " {{{
     let cline = getline(a:lnum)
 
@@ -384,7 +431,7 @@
 
     let synname = synIDattr(synID(a:lnum, coltotest, 0), "name")
 
-    if synname == 'phpStringSingle' || synname == 'phpStringDouble' || synname == 'phpBacktick'
+    if synname ==? 'phpStringSingle' || synname ==? 'phpStringDouble' || synname ==? 'phpBacktick'
 	if cline !~ '^\s*[''"`]'
 	    return "SpecStringEntrails"
 	else
@@ -392,7 +439,7 @@
 	end
     end
 
-    if get(s:SynPHPMatchGroups, synname) || synname =~ '^php' ||  synname =~? '^javaScript'
+    if get(s:SynPHPMatchGroups, tolower(synname)) || synname =~ '^php' ||  synname =~? '^javaScript'
 	return synname
     else
 	return ""
@@ -423,6 +470,10 @@
 
 call ResetPhpOptions()
 
+function! GetPhpIndentVersion()
+    return "1.66-bundle"
+endfun
+
 function! GetPhpIndent()
 
     let b:GetLastRealCodeLNum_ADD = 0
@@ -480,14 +531,14 @@
 	endif
 
 	if synname!=""
-	    if synname == "SpecStringEntrails"
+	    if synname ==? "SpecStringEntrails"
 		let b:InPHPcode = -1 " thumb down
 		let b:InPHPcode_tofind = ""
-	    elseif synname != "phpHereDoc" && synname != "phpHereDocDelimiter"
+	    elseif synname !=? "phpHereDoc" && synname !=? "phpHereDocDelimiter"
 		let b:InPHPcode = 1
 		let b:InPHPcode_tofind = ""
 
-		if synname =~# '^php\%(Doc\)\?Comment'
+		if synname =~? '^php\%(Doc\)\?Comment'
 		    let b:UserIsTypingComment = 1
 		    let b:InPHPcode_checked = 0
 		endif
@@ -556,7 +607,7 @@
 
     if 1 == b:InPHPcode
 
-	if !b:InPHPcode_and_script && last_line =~ '\%(<?.*\)\@<!?>\%(.*<?\)\@!' && IslinePHP(lnum, '?>')=~"Delimiter"
+	if !b:InPHPcode_and_script && last_line =~ '\%(<?.*\)\@<!?>\%(.*<?\)\@!' && IslinePHP(lnum, '?>')=~?"Delimiter"
 	    if cline !~? s:PHP_startindenttag
 		let b:InPHPcode = 0
 		let b:InPHPcode_tofind = s:PHP_startindenttag
@@ -712,7 +763,8 @@
 	    let last_line_num = GetLastRealCodeLNum(last_line_num - 1)
 	    let previous_line = getline(last_line_num)
 	endwhile
-
+    elseif cline =~ '^\s*->'
+	return FindArrowIndent(lnum)
     elseif last_line =~# unstated && cline !~ '^\s*);\='.endline
 	let ind = ind + shiftwidth() " we indent one level further when the preceding line is not stated
 	return ind + addSpecial
@@ -724,7 +776,7 @@
 
 	let isSingleLineBlock = 0
 	while 1
-	    if ! isSingleLineBlock && previous_line =~ '^\s*}\|;\s*}'.endline " XXX
+	    if ! isSingleLineBlock && previous_line =~ '^\s*}\|;\s*}'.endline
 
 		call cursor(last_line_num, 1)
 		if previous_line !~ '^}'
@@ -793,8 +845,7 @@
 
     let AntepenultimateLine = getline(plinnum)
 
-    let last_line = substitute(last_line,"\\(//\\|#\\)\\(\\(\\([^\"']*\\([\"']\\)[^\"']*\\5\\)\\+[^\"']*$\\)\\|\\([^\"']*$\\)\\)",'','')
-
+    let last_line = StripEndlineComments(last_line)
 
     if ind == b:PHP_default_indenting
 	if last_line =~ terminated && last_line !~# s:defaultORcase
@@ -804,11 +855,13 @@
 
     if !LastLineClosed
 
+	let openedparent = -1
+
 
 	if last_line =~# '[{(\[]'.endline || last_line =~? '\h\w*\s*(.*,$' && AntepenultimateLine !~ '[,(\[]'.endline && BalanceDirection(last_line) > 0
 
 	    let dontIndent = 0
-	    if last_line =~ '\S\+\s*{'.endline && last_line !~ '^\s*[)\]]\+\s*{'.endline && last_line !~ s:structureHead
+	    if last_line =~ '\S\+\s*{'.endline && last_line !~ '^\s*[)\]]\+\(\s*:\s*'.s:PHP_validVariable.'\)\=\s*{'.endline && last_line !~ s:structureHead
 		let dontIndent = 1
 	    endif
 
@@ -819,18 +872,17 @@
 	    if b:PHP_BracesAtCodeLevel || b:PHP_vintage_case_default_indent == 1
 		let b:PHP_CurrentIndentLevel = ind
 
-		return ind + addSpecial
 	    endif
 
-	elseif last_line =~ '\S\+\s*),'.endline && BalanceDirection(last_line) < 0
+	elseif last_line =~ '),'.endline && BalanceDirection(last_line) < 0
 	    call cursor(lnum, 1)
-	    call search('),'.endline, 'W') " line never begins with ) so no need for 'c' flag
+	    call searchpos('),'.endline, 'cW')
 	    let openedparent = searchpair('(', '', ')', 'bW', 'Skippmatch()')
 	    if openedparent != lnum
 		let ind = indent(openedparent)
 	    endif
 
-	elseif last_line =~ '^\s*'.s:blockstart
+	elseif last_line =~ s:structureHead
 	    let ind = ind + shiftwidth()
 
 
@@ -838,9 +890,17 @@
 	    let ind = ind + shiftwidth()
 	endif
 
+
+	if openedparent >= 0
+	    let last_line = StripEndlineComments(getline(openedparent))
+	endif
     endif
 
-    if cline =~  '^\s*[)\]];\='
+    if cline =~ '^\s*[)\]];\='
+	let ind = ind - shiftwidth()
+    endif
+
+    if last_line =~ '^\s*->' && last_line !~? s:structureHead && BalanceDirection(last_line) <= 0
 	let ind = ind - shiftwidth()
     endif
 
diff --git a/runtime/syntax/muttrc.vim b/runtime/syntax/muttrc.vim
index e4395fd..830664e 100644
--- a/runtime/syntax/muttrc.vim
+++ b/runtime/syntax/muttrc.vim
@@ -2,9 +2,9 @@
 " Language:	Mutt setup files
 " Original:	Preben 'Peppe' Guldberg <peppe-vim@wielders.org>
 " Maintainer:	Kyle Wheeler <kyle-muttrc.vim@memoryhole.net>
-" Last Change:	18 August 2016
+" Last Change:	21 May 2018
 
-" This file covers mutt version 1.7.0
+" This file covers mutt version 1.10.0
 
 " quit when a syntax file was already loaded
 if exists("b:current_syntax")
@@ -104,142 +104,175 @@
 syn keyword muttrcVarBool	skipwhite contained 
 			\ allow_8bit allow_ansi arrow_cursor ascii_chars askbcc askcc attach_split
 			\ auto_tag autoedit beep beep_new bounce_delivered braille_friendly
-			\ check_mbox_size check_new collapse_unread confirmappend confirmcreate
-			\ crypt_autoencrypt crypt_autopgp crypt_autosign crypt_autosmime
-			\ crypt_confirmhook crypt_opportunistic_encrypt crypt_replyencrypt
-			\ crypt_replysign crypt_replysignencrypted crypt_timestamp crypt_use_gpgme
-			\ crypt_use_pka delete_untag digest_collapse duplicate_threads edit_hdrs
-			\ edit_headers encode_from envelope_from fast_reply fcc_clear followup_to
-			\ force_name forw_decode forw_decrypt forw_quote forward_decode forward_decrypt
-			\ forward_quote hdrs header help hidden_host hide_limited hide_missing
-			\ hide_thread_subject hide_top_limited hide_top_missing honor_disposition
-			\ idn_decode idn_encode ignore_linear_white_space ignore_list_reply_to
-			\ imap_check_subscribed imap_list_subscribed imap_passive imap_peek
-			\ imap_servernoise implicit_autoview include_onlyfirst keep_flagged
+			\ browser_abbreviate_mailboxes change_folder_next check_mbox_size check_new
+			\ collapse_unread confirmappend confirmcreate crypt_autoencrypt crypt_autopgp
+			\ crypt_autosign crypt_autosmime crypt_confirmhook crypt_opportunistic_encrypt
+			\ crypt_replyencrypt crypt_replysign crypt_replysignencrypted crypt_timestamp
+			\ crypt_use_gpgme crypt_use_pka delete_untag digest_collapse duplicate_threads
+			\ edit_hdrs edit_headers encode_from envelope_from fast_reply fcc_clear
+			\ flag_safe followup_to force_name forw_decode forw_decrypt forw_quote
+			\ forward_decode forward_decrypt forward_quote hdrs header
+			\ header_color_partial help hidden_host hide_limited hide_missing
+			\ hide_thread_subject hide_top_limited hide_top_missing history_remove_dups
+			\ honor_disposition idn_decode idn_encode ignore_linear_white_space
+			\ ignore_list_reply_to imap_check_subscribed imap_list_subscribed imap_passive
+			\ imap_peek imap_servernoise implicit_autoview include_onlyfirst keep_flagged
 			\ mail_check_recent mail_check_stats mailcap_sanitize maildir_check_cur
 			\ maildir_header_cache_verify maildir_trash mark_old markers menu_move_off
 			\ menu_scroll message_cache_clean meta_key metoo mh_purge mime_forward_decode
-			\ narrow_tree pager_stop pgp_auto_decode pgp_auto_traditional pgp_autoencrypt
-			\ pgp_autoinline pgp_autosign pgp_check_exit pgp_create_traditional
-			\ pgp_ignore_subkeys pgp_long_ids pgp_replyencrypt pgp_replyinline pgp_replysign
-			\ pgp_replysignencrypted pgp_retainable_sigs pgp_show_unusable pgp_strict_enc
-			\ pgp_use_gpg_agent pipe_decode pipe_split pop_auth_try_all pop_last
-			\ postpone_encrypt postpone_encrypt_as print_decode print_split prompt_after
-			\ read_only reflow_space_quotes reflow_text reflow_wrap reply_self resolve
-			\ resume_draft_files resume_edited_draft_files reverse_alias reverse_name
-			\ reverse_realname rfc2047_parameters save_address save_empty save_name score
-			\ sidebar_folder_indent sidebar_new_mail_only sidebar_next_new_wrap
-			\ sidebar_short_path sidebar_sort sidebar_visible sig_dashes sig_on_top
-			\ smart_wrap smime_ask_cert_label smime_decrypt_use_default_key smime_is_default
-			\ sort_re ssl_force_tls ssl_use_sslv2 ssl_use_sslv3 ssl_use_tlsv1
-			\ ssl_usesystemcerts ssl_verify_dates ssl_verify_host status_on_top strict_mime
-			\ strict_threads suspend text_flowed thorough_search thread_received tilde
-			\ ts_enabled uncollapse_jump use_8bitmime use_domain use_envelope_from use_from
-			\ use_idn use_ipv6 user_agent wait_key weed wrap_search write_bcc
+			\ mime_type_query_first narrow_tree pager_stop pgp_auto_decode
+			\ pgp_auto_traditional pgp_autoencrypt pgp_autoinline pgp_autosign
+			\ pgp_check_exit pgp_create_traditional pgp_ignore_subkeys pgp_long_ids
+			\ pgp_replyencrypt pgp_replyinline pgp_replysign pgp_replysignencrypted
+			\ pgp_retainable_sigs pgp_self_encrypt pgp_self_encrypt_as pgp_show_unusable
+			\ pgp_strict_enc pgp_use_gpg_agent pipe_decode pipe_split pop_auth_try_all
+			\ pop_last postpone_encrypt postpone_encrypt_as print_decode print_split
+			\ prompt_after read_only reflow_space_quotes reflow_text reflow_wrap
+			\ reply_self resolve resume_draft_files resume_edited_draft_files
+			\ reverse_alias reverse_name reverse_realname rfc2047_parameters save_address
+			\ save_empty save_name score sidebar_folder_indent sidebar_new_mail_only
+			\ sidebar_next_new_wrap sidebar_short_path sidebar_sort sidebar_visible
+			\ sig_dashes sig_on_top smart_wrap smime_ask_cert_label
+			\ smime_decrypt_use_default_key smime_is_default smime_self_encrypt
+			\ smime_self_encrypt_as sort_re ssl_force_tls ssl_use_sslv2 ssl_use_sslv3
+			\ ssl_use_tlsv1 ssl_usesystemcerts ssl_verify_dates ssl_verify_host
+			\ ssl_verify_partial_chains status_on_top strict_mime strict_threads suspend
+			\ text_flowed thorough_search thread_received tilde ts_enabled uncollapse_jump
+			\ use_8bitmime use_domain use_envelope_from use_from use_idn use_ipv6
+			\ uncollapse_new user_agent wait_key weed wrap_search write_bcc
 			\ nextgroup=muttrcSetBoolAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 
 syn keyword muttrcVarBool	skipwhite contained 
-			\ noallow_8bit noallow_ansi noarrow_cursor noascii_chars noaskbcc noaskcc noattach_split
-			\ noauto_tag noautoedit nobeep nobeep_new nobounce_delivered nobraille_friendly
-			\ nocheck_mbox_size nocheck_new nocollapse_unread noconfirmappend noconfirmcreate
-			\ nocrypt_autoencrypt nocrypt_autopgp nocrypt_autosign nocrypt_autosmime
-			\ nocrypt_confirmhook nocrypt_opportunistic_encrypt nocrypt_replyencrypt
-			\ nocrypt_replysign nocrypt_replysignencrypted nocrypt_timestamp nocrypt_use_gpgme
-			\ nocrypt_use_pka nodelete_untag nodigest_collapse noduplicate_threads noedit_hdrs
-			\ noedit_headers noencode_from noenvelope_from nofast_reply nofcc_clear nofollowup_to
-			\ noforce_name noforw_decode noforw_decrypt noforw_quote noforward_decode noforward_decrypt
-			\ noforward_quote nohdrs noheader nohelp nohidden_host nohide_limited nohide_missing
-			\ nohide_thread_subject nohide_top_limited nohide_top_missing nohonor_disposition
-			\ noidn_decode noidn_encode noignore_linear_white_space noignore_list_reply_to
-			\ noimap_check_subscribed noimap_list_subscribed noimap_passive noimap_peek
-			\ noimap_servernoise noimplicit_autoview noinclude_onlyfirst nokeep_flagged
-			\ nomail_check_recent nomail_check_stats nomailcap_sanitize nomaildir_check_cur
-			\ nomaildir_header_cache_verify nomaildir_trash nomark_old nomarkers nomenu_move_off
-			\ nomenu_scroll nomessage_cache_clean nometa_key nometoo nomh_purge nomime_forward_decode
-			\ nonarrow_tree nopager_stop nopgp_auto_decode nopgp_auto_traditional nopgp_autoencrypt
+			\ noallow_8bit noallow_ansi noarrow_cursor noascii_chars noaskbcc noaskcc
+			\ noattach_split noauto_tag noautoedit nobeep nobeep_new nobounce_delivered
+			\ nobraille_friendly nobrowser_abbreviate_mailboxes nochange_folder_next
+			\ nocheck_mbox_size nocheck_new nocollapse_unread noconfirmappend
+			\ noconfirmcreate nocrypt_autoencrypt nocrypt_autopgp nocrypt_autosign
+			\ nocrypt_autosmime nocrypt_confirmhook nocrypt_opportunistic_encrypt
+			\ nocrypt_replyencrypt nocrypt_replysign nocrypt_replysignencrypted
+			\ nocrypt_timestamp nocrypt_use_gpgme nocrypt_use_pka nodelete_untag
+			\ nodigest_collapse noduplicate_threads noedit_hdrs noedit_headers
+			\ noencode_from noenvelope_from nofast_reply nofcc_clear noflag_safe
+			\ nofollowup_to noforce_name noforw_decode noforw_decrypt noforw_quote
+			\ noforward_decode noforward_decrypt noforward_quote nohdrs noheader
+			\ noheader_color_partial nohelp nohidden_host nohide_limited nohide_missing
+			\ nohide_thread_subject nohide_top_limited nohide_top_missing
+			\ nohistory_remove_dups nohonor_disposition noidn_decode noidn_encode
+			\ noignore_linear_white_space noignore_list_reply_to noimap_check_subscribed
+			\ noimap_list_subscribed noimap_passive noimap_peek noimap_servernoise
+			\ noimplicit_autoview noinclude_onlyfirst nokeep_flagged nomail_check_recent
+			\ nomail_check_stats nomailcap_sanitize nomaildir_check_cur
+			\ nomaildir_header_cache_verify nomaildir_trash nomark_old nomarkers
+			\ nomenu_move_off nomenu_scroll nomessage_cache_clean nometa_key nometoo
+			\ nomh_purge nomime_forward_decode nomime_type_query_first nonarrow_tree
+			\ nopager_stop nopgp_auto_decode nopgp_auto_traditional nopgp_autoencrypt
 			\ nopgp_autoinline nopgp_autosign nopgp_check_exit nopgp_create_traditional
-			\ nopgp_ignore_subkeys nopgp_long_ids nopgp_replyencrypt nopgp_replyinline nopgp_replysign
-			\ nopgp_replysignencrypted nopgp_retainable_sigs nopgp_show_unusable nopgp_strict_enc
-			\ nopgp_use_gpg_agent nopipe_decode nopipe_split nopop_auth_try_all nopop_last
-			\ nopostpone_encrypt nopostpone_encrypt_as noprint_decode noprint_split noprompt_after
-			\ noread_only noreflow_space_quotes noreflow_text noreflow_wrap noreply_self noresolve
-			\ noresume_draft_files noresume_edited_draft_files noreverse_alias noreverse_name
-			\ noreverse_realname norfc2047_parameters nosave_address nosave_empty nosave_name noscore
-			\ nosidebar_folder_indent nosidebar_new_mail_only nosidebar_next_new_wrap
-			\ nosidebar_short_path nosidebar_sort nosidebar_visible nosig_dashes nosig_on_top
-			\ nosmart_wrap nosmime_ask_cert_label nosmime_decrypt_use_default_key nosmime_is_default
-			\ nosort_re nossl_force_tls nossl_use_sslv2 nossl_use_sslv3 nossl_use_tlsv1
-			\ nossl_usesystemcerts nossl_verify_dates nossl_verify_host nostatus_on_top nostrict_mime
-			\ nostrict_threads nosuspend notext_flowed nothorough_search nothread_received notilde
-			\ nots_enabled nouncollapse_jump nouse_8bitmime nouse_domain nouse_envelope_from nouse_from
-			\ nouse_idn nouse_ipv6 nouser_agent nowait_key noweed nowrap_search nowrite_bcc
+			\ nopgp_ignore_subkeys nopgp_long_ids nopgp_replyencrypt nopgp_replyinline
+			\ nopgp_replysign nopgp_replysignencrypted nopgp_retainable_sigs
+			\ nopgp_self_encrypt nopgp_self_encrypt_as nopgp_show_unusable
+			\ nopgp_strict_enc nopgp_use_gpg_agent nopipe_decode nopipe_split
+			\ nopop_auth_try_all nopop_last nopostpone_encrypt nopostpone_encrypt_as
+			\ noprint_decode noprint_split noprompt_after noread_only
+			\ noreflow_space_quotes noreflow_text noreflow_wrap noreply_self noresolve
+			\ noresume_draft_files noresume_edited_draft_files noreverse_alias
+			\ noreverse_name noreverse_realname norfc2047_parameters nosave_address
+			\ nosave_empty nosave_name noscore nosidebar_folder_indent
+			\ nosidebar_new_mail_only nosidebar_next_new_wrap nosidebar_short_path
+			\ nosidebar_sort nosidebar_visible nosig_dashes nosig_on_top nosmart_wrap
+			\ nosmime_ask_cert_label nosmime_decrypt_use_default_key nosmime_is_default
+			\ nosmime_self_encrypt nosmime_self_encrypt_as nosort_re nossl_force_tls
+			\ nossl_use_sslv2 nossl_use_sslv3 nossl_use_tlsv1 nossl_usesystemcerts
+			\ nossl_verify_dates nossl_verify_host nossl_verify_partial_chains
+			\ nostatus_on_top nostrict_mime nostrict_threads nosuspend notext_flowed
+			\ nothorough_search nothread_received notilde nots_enabled nouncollapse_jump
+			\ nouse_8bitmime nouse_domain nouse_envelope_from nouse_from nouse_idn
+			\ nouse_ipv6 nouncollapse_new nouser_agent nowait_key noweed nowrap_search
+			\ nowrite_bcc
 			\ nextgroup=muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 
 syn keyword muttrcVarBool	skipwhite contained
-			\ invallow_8bit invallow_ansi invarrow_cursor invascii_chars invaskbcc invaskcc invattach_split
-			\ invauto_tag invautoedit invbeep invbeep_new invbounce_delivered invbraille_friendly
-			\ invcheck_mbox_size invcheck_new invcollapse_unread invconfirmappend invconfirmcreate
-			\ invcrypt_autoencrypt invcrypt_autopgp invcrypt_autosign invcrypt_autosmime
-			\ invcrypt_confirmhook invcrypt_opportunistic_encrypt invcrypt_replyencrypt
-			\ invcrypt_replysign invcrypt_replysignencrypted invcrypt_timestamp invcrypt_use_gpgme
-			\ invcrypt_use_pka invdelete_untag invdigest_collapse invduplicate_threads invedit_hdrs
-			\ invedit_headers invencode_from invenvelope_from invfast_reply invfcc_clear invfollowup_to
-			\ invforce_name invforw_decode invforw_decrypt invforw_quote invforward_decode invforward_decrypt
-			\ invforward_quote invhdrs invheader invhelp invhidden_host invhide_limited invhide_missing
-			\ invhide_thread_subject invhide_top_limited invhide_top_missing invhonor_disposition
-			\ invidn_decode invidn_encode invignore_linear_white_space invignore_list_reply_to
-			\ invimap_check_subscribed invimap_list_subscribed invimap_passive invimap_peek
-			\ invimap_servernoise invimplicit_autoview invinclude_onlyfirst invkeep_flagged
-			\ invmail_check_recent invmail_check_stats invmailcap_sanitize invmaildir_check_cur
-			\ invmaildir_header_cache_verify invmaildir_trash invmark_old invmarkers invmenu_move_off
-			\ invmenu_scroll invmessage_cache_clean invmeta_key invmetoo invmh_purge invmime_forward_decode
-			\ invnarrow_tree invpager_stop invpgp_auto_decode invpgp_auto_traditional invpgp_autoencrypt
-			\ invpgp_autoinline invpgp_autosign invpgp_check_exit invpgp_create_traditional
-			\ invpgp_ignore_subkeys invpgp_long_ids invpgp_replyencrypt invpgp_replyinline invpgp_replysign
-			\ invpgp_replysignencrypted invpgp_retainable_sigs invpgp_show_unusable invpgp_strict_enc
-			\ invpgp_use_gpg_agent invpipe_decode invpipe_split invpop_auth_try_all invpop_last
-			\ invpostpone_encrypt invpostpone_encrypt_as invprint_decode invprint_split invprompt_after
-			\ invread_only invreflow_space_quotes invreflow_text invreflow_wrap invreply_self invresolve
-			\ invresume_draft_files invresume_edited_draft_files invreverse_alias invreverse_name
-			\ invreverse_realname invrfc2047_parameters invsave_address invsave_empty invsave_name invscore
-			\ invsidebar_folder_indent invsidebar_new_mail_only invsidebar_next_new_wrap
-			\ invsidebar_short_path invsidebar_sort invsidebar_visible invsig_dashes invsig_on_top
-			\ invsmart_wrap invsmime_ask_cert_label invsmime_decrypt_use_default_key invsmime_is_default
-			\ invsort_re invssl_force_tls invssl_use_sslv2 invssl_use_sslv3 invssl_use_tlsv1
-			\ invssl_usesystemcerts invssl_verify_dates invssl_verify_host invstatus_on_top invstrict_mime
-			\ invstrict_threads invsuspend invtext_flowed invthorough_search invthread_received invtilde
-			\ invts_enabled invuncollapse_jump invuse_8bitmime invuse_domain invuse_envelope_from invuse_from
-			\ invuse_idn invuse_ipv6 invuser_agent invwait_key invweed invwrap_search invwrite_bcc
+			\ invallow_8bit invallow_ansi invarrow_cursor invascii_chars invaskbcc
+			\ invaskcc invattach_split invauto_tag invautoedit invbeep invbeep_new
+			\ invbounce_delivered invbraille_friendly invbrowser_abbreviate_mailboxes
+			\ invchange_folder_next invcheck_mbox_size invcheck_new invcollapse_unread
+			\ invconfirmappend invconfirmcreate invcrypt_autoencrypt invcrypt_autopgp
+			\ invcrypt_autosign invcrypt_autosmime invcrypt_confirmhook
+			\ invcrypt_opportunistic_encrypt invcrypt_replyencrypt invcrypt_replysign
+			\ invcrypt_replysignencrypted invcrypt_timestamp invcrypt_use_gpgme
+			\ invcrypt_use_pka invdelete_untag invdigest_collapse invduplicate_threads
+			\ invedit_hdrs invedit_headers invencode_from invenvelope_from invfast_reply
+			\ invfcc_clear invflag_safe invfollowup_to invforce_name invforw_decode
+			\ invforw_decrypt invforw_quote invforward_decode invforward_decrypt
+			\ invforward_quote invhdrs invheader invheader_color_partial invhelp
+			\ invhidden_host invhide_limited invhide_missing invhide_thread_subject
+			\ invhide_top_limited invhide_top_missing invhistory_remove_dups
+			\ invhonor_disposition invidn_decode invidn_encode
+			\ invignore_linear_white_space invignore_list_reply_to
+			\ invimap_check_subscribed invimap_list_subscribed invimap_passive
+			\ invimap_peek invimap_servernoise invimplicit_autoview invinclude_onlyfirst
+			\ invkeep_flagged invmail_check_recent invmail_check_stats invmailcap_sanitize
+			\ invmaildir_check_cur invmaildir_header_cache_verify invmaildir_trash
+			\ invmark_old invmarkers invmenu_move_off invmenu_scroll
+			\ invmessage_cache_clean invmeta_key invmetoo invmh_purge
+			\ invmime_forward_decode invmime_type_query_first invnarrow_tree invpager_stop
+			\ invpgp_auto_decode invpgp_auto_traditional invpgp_autoencrypt
+			\ invpgp_autoinline invpgp_autosign invpgp_check_exit
+			\ invpgp_create_traditional invpgp_ignore_subkeys invpgp_long_ids
+			\ invpgp_replyencrypt invpgp_replyinline invpgp_replysign
+			\ invpgp_replysignencrypted invpgp_retainable_sigs invpgp_self_encrypt
+			\ invpgp_self_encrypt_as invpgp_show_unusable invpgp_strict_enc
+			\ invpgp_use_gpg_agent invpipe_decode invpipe_split invpop_auth_try_all
+			\ invpop_last invpostpone_encrypt invpostpone_encrypt_as invprint_decode
+			\ invprint_split invprompt_after invread_only invreflow_space_quotes
+			\ invreflow_text invreflow_wrap invreply_self invresolve invresume_draft_files
+			\ invresume_edited_draft_files invreverse_alias invreverse_name
+			\ invreverse_realname invrfc2047_parameters invsave_address invsave_empty
+			\ invsave_name invscore invsidebar_folder_indent invsidebar_new_mail_only
+			\ invsidebar_next_new_wrap invsidebar_short_path invsidebar_sort
+			\ invsidebar_visible invsig_dashes invsig_on_top invsmart_wrap
+			\ invsmime_ask_cert_label invsmime_decrypt_use_default_key invsmime_is_default
+			\ invsmime_self_encrypt invsmime_self_encrypt_as invsort_re invssl_force_tls
+			\ invssl_use_sslv2 invssl_use_sslv3 invssl_use_tlsv1 invssl_usesystemcerts
+			\ invssl_verify_dates invssl_verify_host invssl_verify_partial_chains
+			\ invstatus_on_top invstrict_mime invstrict_threads invsuspend invtext_flowed
+			\ invthorough_search invthread_received invtilde invts_enabled
+			\ invuncollapse_jump invuse_8bitmime invuse_domain invuse_envelope_from
+			\ invuse_from invuse_idn invuse_ipv6 invuncollapse_new invuser_agent
+			\ invwait_key invweed invwrap_search invwrite_bcc
 			\ nextgroup=muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 
 syn keyword muttrcVarQuad	skipwhite contained
-			\ abort_nosubject abort_unmodified bounce copy crypt_verify_sig delete
-			\ fcc_attach forward_edit honor_followup_to include mime_forward
+			\ abort_nosubject abort_unmodified abort_noattach bounce copy crypt_verify_sig
+			\ delete fcc_attach forward_edit honor_followup_to include mime_forward
 			\ mime_forward_rest mime_fwd move pgp_mime_auto pgp_verify_sig pop_delete
 			\ pop_reconnect postpone print quit recall reply_to ssl_starttls
 			\ nextgroup=muttrcSetQuadAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 
 syn keyword muttrcVarQuad	skipwhite contained
-			\ noabort_nosubject noabort_unmodified nobounce nocopy nocrypt_verify_sig nodelete
-			\ nofcc_attach noforward_edit nohonor_followup_to noinclude nomime_forward
-			\ nomime_forward_rest nomime_fwd nomove nopgp_mime_auto nopgp_verify_sig nopop_delete
-			\ nopop_reconnect nopostpone noprint noquit norecall noreply_to nossl_starttls
+			\ noabort_nosubject noabort_unmodified noabort_noattach nobounce nocopy
+			\ nocrypt_verify_sig nodelete nofcc_attach noforward_edit nohonor_followup_to
+			\ noinclude nomime_forward nomime_forward_rest nomime_fwd nomove
+			\ nopgp_mime_auto nopgp_verify_sig nopop_delete nopop_reconnect nopostpone
+			\ noprint noquit norecall noreply_to nossl_starttls
 			\ nextgroup=muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 
 syn keyword muttrcVarQuad	skipwhite contained
-			\ invabort_nosubject invabort_unmodified invbounce invcopy invcrypt_verify_sig invdelete
-			\ invfcc_attach invforward_edit invhonor_followup_to invinclude invmime_forward
-			\ invmime_forward_rest invmime_fwd invmove invpgp_mime_auto invpgp_verify_sig invpop_delete
-			\ invpop_reconnect invpostpone invprint invquit invrecall invreply_to invssl_starttls
+			\ invabort_nosubject invabort_unmodified invabort_noattach invbounce invcopy
+			\ invcrypt_verify_sig invdelete invfcc_attach invforward_edit
+			\ invhonor_followup_to invinclude invmime_forward invmime_forward_rest
+			\ invmime_fwd invmove invpgp_mime_auto invpgp_verify_sig invpop_delete
+			\ invpop_reconnect invpostpone invprint invquit invrecall invreply_to
+			\ invssl_starttls
 			\ nextgroup=muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 
 syn keyword muttrcVarNum	skipwhite contained
-			\ connect_timeout history imap_keepalive imap_pipeline_depth mail_check
-			\ mail_check_stats_interval menu_context net_inc pager_context pager_index_lines
-			\ pgp_timeout pop_checkinterval read_inc save_history score_threshold_delete
-			\ score_threshold_flag score_threshold_read search_context sendmail_wait
-			\ sidebar_width sleep_time smime_timeout ssl_min_dh_prime_bits time_inc timeout
-			\ wrap wrap_headers wrapmargin write_inc
+			\ connect_timeout error_history history imap_keepalive imap_pipeline_depth
+			\ imap_poll_timeout mail_check mail_check_stats_interval menu_context net_inc
+			\ pager_context pager_index_lines pgp_timeout pop_checkinterval read_inc
+			\ save_history score_threshold_delete score_threshold_flag
+			\ score_threshold_read search_context sendmail_wait sidebar_width sleep_time
+			\ smime_timeout ssl_min_dh_prime_bits time_inc timeout wrap wrap_headers
+			\ wrapmargin write_inc
 			\ nextgroup=muttrcSetNumAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 
 syn match muttrcFormatErrors contained /%./
@@ -284,7 +317,7 @@
 syn match muttrcQueryFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[acent%]/
 syn match muttrcQueryFormatConditionals contained /%?[e]?/ nextgroup=muttrcFormatConditionals2
 " The following info was pulled from mutt_attach_fmt in recvattach.c
-syn match muttrcAttachFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[CcDdefImMnQstTuX%]/
+syn match muttrcAttachFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[CcDdeFfImMnQstTuX%]/
 syn match muttrcAttachFormatEscapes contained /%[>|*]./
 syn match muttrcAttachFormatConditionals contained /%?[CcdDefInmMQstTuX]?/ nextgroup=muttrcFormatConditionals2
 syn match muttrcFormatConditionals2 contained /[^?]*?/
@@ -308,7 +341,7 @@
 syn match muttrcPGPCmdFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[pfsar%]/
 syn match muttrcPGPCmdFormatConditionals contained /%?[pfsar]?/ nextgroup=muttrcFormatConditionals2
 " The following info was pulled from status_format_str in status.c
-syn match muttrcStatusFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[bdfFhlLmMnopPrsStuvV%]/
+syn match muttrcStatusFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[bdfFhlLmMnopPRrsStuvV%]/
 syn match muttrcStatusFormatEscapes contained /%[>|*]./
 syn match muttrcStatusFormatConditionals contained /%?[bdFlLmMnoptuV]?/ nextgroup=muttrcFormatConditionals2
 " This matches the documentation, but directly contradicts the code 
@@ -357,27 +390,27 @@
 
 syn match muttrcVarStr		contained skipwhite 'my_[a-zA-Z0-9_]\+' nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 syn keyword muttrcVarStr	contained skipwhite
-			\ alias_file assumed_charset attach_charset attach_sep certificate_file charset
-			\ config_charset content_type default_hook display_filter dotlock_program
-			\ dsn_notify dsn_return editor entropy_file envelope_from_address escape folder
-			\ forw_format forward_format from gecos_mask hdr_format header_cache
-			\ header_cache_compress header_cache_pagesize history_file hostname
-			\ imap_authenticators imap_delim_chars imap_headers imap_idle imap_login
-			\ imap_pass imap_user indent_str indent_string ispell locale mailcap_path mask
-			\ mbox mbox_type message_cachedir mh_seq_flagged mh_seq_replied mh_seq_unseen
-			\ mixmaster msg_format pager pgp_decryption_okay pgp_good_sign
-			\ pgp_mime_signature_description pgp_mime_signature_filename pgp_sign_as
-			\ pgp_sort_keys pipe_sep pop_authenticators pop_host pop_pass pop_user
-			\ post_indent_str post_indent_string postpone_encrypt_as postponed preconnect
-			\ print_cmd print_command query_command quote_regexp realname record
-			\ reply_regexp send_charset sendmail shell sidebar_delim sidebar_delim_chars
-			\ sidebar_divider_char sidebar_format sidebar_indent_string sidebar_sort_method
-			\ signature simple_search smileys smime_ca_location smime_certificates
-			\ smime_default_key smime_encrypt_with smime_keys smime_sign_as
-			\ smime_sign_digest_alg smtp_authenticators smtp_pass smtp_url sort sort_alias
-			\ sort_aux sort_browser spam_separator spoolfile ssl_ca_certificates_file
-			\ ssl_ciphers ssl_client_cert status_chars tmpdir to_chars trash ts_icon_format
-			\ ts_status_format tunnel visual
+			\ abort_noattach_regexp alias_file assumed_charset attach_charset attach_sep
+			\ attribution_locale certificate_file charset config_charset content_type
+			\ default_hook display_filter dotlock_program dsn_notify dsn_return editor
+		        \ entropy_file envelope_from_address escape folder forw_format
+		        \ forward_attribution_intro forward_attribution_trailer forward_format from gecos_mask
+		        \ hdr_format header_cache header_cache_compress header_cache_pagesize history_file
+		        \ hostname imap_authenticators imap_delim_chars imap_headers imap_idle imap_login
+		        \ imap_pass imap_user indent_str indent_string ispell locale mailcap_path
+		        \ mark_macro_prefix mask mbox mbox_type message_cachedir mh_seq_flagged mh_seq_replied
+		        \ mh_seq_unseen mime_type_query_command mixmaster msg_format new_mail_command pager
+		        \ pgp_default_key pgp_decryption_okay pgp_good_sign pgp_mime_signature_description
+		        \ pgp_mime_signature_filename pgp_sign_as pgp_sort_keys pipe_sep pop_authenticators
+		        \ pop_host pop_pass pop_user post_indent_str post_indent_string postpone_encrypt_as
+		        \ postponed preconnect print_cmd print_command query_command quote_regexp realname
+		        \ record reply_regexp send_charset sendmail shell sidebar_delim sidebar_delim_chars
+		        \ sidebar_divider_char sidebar_format sidebar_indent_string sidebar_sort_method
+		        \ signature simple_search smileys smime_ca_location smime_certificates
+		        \ smime_default_key smime_encrypt_with smime_keys smime_sign_as smime_sign_digest_alg
+		        \ smtp_authenticators smtp_pass smtp_url sort sort_alias sort_aux sort_browser
+		        \ spam_separator spoolfile ssl_ca_certificates_file ssl_ciphers ssl_client_cert
+		        \ status_chars tmpdir to_chars trash ts_icon_format ts_status_format tunnel visual
 			\ nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr
 
 " Present in 1.4.2.1 (pgp_create_traditional was a bool then)
@@ -396,6 +429,7 @@
 			\ mailto_allow mime_lookup my_hdr pgp-hook push score sidebar_whitelist source
 			\ unalternative_order unalternative_order unauto_view ungroup unhdr_order
 			\ unignore unmailboxes unmailto_allow unmime_lookup unmono unmy_hdr unscore
+			\ unsidebar_whitelist
 syn keyword muttrcCommand	skipwhite charset-hook nextgroup=muttrcRXString
 syn keyword muttrcCommand	skipwhite unhook nextgroup=muttrcHooks
 
@@ -430,7 +464,7 @@
 syn match muttrcEscapedVariable	contained "\\\$[a-zA-Z_-]\+"
 
 syn match muttrcBadAction	contained "[^<>]\+" contains=muttrcEmail
-syn match muttrcFunction	contained "\<\%(attach\|bounce\|copy\|delete\|display\|flag\|forward\|parent\|pipe\|postpone\|print\|purge\|recall\|resend\|save\|send\|tag\|undelete\)-message\>"
+syn match muttrcFunction	contained "\<\%(attach\|bounce\|copy\|delete\|display\|flag\|forward\|mark\|parent\|pipe\|postpone\|print\|purge\|recall\|resend\|root\|save\|send\|tag\|undelete\)-message\>"
 syn match muttrcFunction	contained "\<\%(delete\|next\|previous\|read\|tag\|break\|undelete\)-thread\>"
 syn match muttrcFunction	contained "\<link-threads\>"
 syn match muttrcFunction	contained "\<\%(backward\|capitalize\|downcase\|forward\|kill\|upcase\)-word\>"
@@ -442,10 +476,12 @@
 syn match muttrcFunction	contained "\<decode-\%(copy\|save\)\>"
 syn match muttrcFunction	contained "\<delete-\%(char\|pattern\|subthread\)\>"
 syn match muttrcFunction	contained "\<display-\%(address\|toggle-weed\)\>"
-syn match muttrcFunction	contained "\<edit\%(-\%(bcc\|cc\|description\|encoding\|fcc\|file\|from\|headers\|mime\|reply-to\|subject\|to\|type\)\)\?\>"
+syn match muttrcFunction	contained "\<echo\>"
+syn match muttrcFunction	contained "\<edit\%(-\%(bcc\|cc\|description\|encoding\|fcc\|file\|from\|headers\|label\|mime\|reply-to\|subject\|to\|type\)\)\?\>"
 syn match muttrcFunction	contained "\<enter-\%(command\|mask\)\>"
+syn match muttrcFunction	contained "\<error-history\>"
 syn match muttrcFunction	contained "\<half-\%(up\|down\)\>"
-syn match muttrcFunction	contained "\<history-\%(up\|down\)\>"
+syn match muttrcFunction	contained "\<history-\%(up\|down\|search\)\>"
 syn match muttrcFunction	contained "\<kill-\%(eol\|eow\|line\)\>"
 syn match muttrcFunction	contained "\<next-\%(line\|new\%(-then-unread\)\?\|page\|subthread\|undeleted\|unread\|unread-mailbox\)\>"
 syn match muttrcFunction	contained "\<previous-\%(line\|new\%(-then-unread\)\?\|page\|subthread\|undeleted\|unread\)\>"
@@ -458,6 +494,9 @@
 syn match muttrcFunction	contained "\<toggle-\%(mailboxes\|new\|quoted\|subscribed\|unlink\|write\)\>"
 syn match muttrcFunction	contained "\<undelete-\%(pattern\|subthread\)\>"
 syn match muttrcFunction	contained "\<collapse-\%(parts\|thread\|all\)\>"
+syn match muttrcFunction	contained "\<rename-attachment\>"
+syn match muttrcFunction	contained "\<subjectrx\>"
+syn match muttrcFunction	contained "\<\%(un\)\?setenv\>"
 syn match muttrcFunction	contained "\<view-\%(attach\|attachments\|file\|mailcap\|name\|text\)\>"
 syn match muttrcFunction	contained "\<\%(backspace\|backward-char\|bol\|bottom\|bottom-page\|buffy-cycle\|clear-flag\|complete\%(-query\)\?\|copy-file\|create-alias\|detach-file\|eol\|exit\|extract-keys\|\%(imap-\)\?fetch-mail\|forget-passphrase\|forward-char\|group-reply\|help\|ispell\|jump\|limit\|list-reply\|mail\|mail-key\|mark-as-new\|middle-page\|new-mime\|noop\|pgp-menu\|query\|query-append\|quit\|quote-char\|read-subthread\|redraw-screen\|refresh\|rename-file\|reply\|select-new\|set-flag\|shell-escape\|skip-quoted\|sort\|subscribe\|sync-mailbox\|top\|top-page\|transpose-chars\|unsubscribe\|untag-pattern\|verify-key\|what-key\|write-fcc\)\>"
 syn keyword muttrcFunction	contained imap-logout-all
@@ -559,6 +598,7 @@
 syn region muttrcPattern contained matchgroup=Type keepend skipwhite start=+"+ skip=+\\"+ end=+"+ contains=muttrcSimplePat,muttrcUnHighlightSpace,muttrcSimplePatMetas
 syn region muttrcPattern contained matchgroup=Type keepend skipwhite start=+'+ skip=+\\'+ end=+'+ contains=muttrcSimplePat,muttrcUnHighlightSpace,muttrcSimplePatMetas
 syn region muttrcPattern contained keepend skipwhite start=+[~](+ end=+)+ skip=+\\)+ contains=muttrcSimplePat
+syn region muttrcPattern contained keepend skipwhite start=+[~][<>](+ end=+)+ skip=+\\)+ contains=muttrcSimplePat
 syn match muttrcPattern contained skipwhite /[~][A-Za-z]/ contains=muttrcSimplePat
 syn match muttrcPattern contained skipwhite /[.]/
 syn region muttrcPatternInner contained keepend start=+"[~=%!(^]+ms=s+1 skip=+\\"+ end=+"+me=e-1 contains=muttrcSimplePat,muttrcUnHighlightSpace,muttrcSimplePatMetas
diff --git a/runtime/syntax/tmux.vim b/runtime/syntax/tmux.vim
index 1ba5f67..62c0ce5 100644
--- a/runtime/syntax/tmux.vim
+++ b/runtime/syntax/tmux.vim
@@ -1,5 +1,5 @@
 " Language: tmux(1) configuration file
-" Version: 2.3 (git-14dc2ac)
+" Version: 2.7 (git-e4e060f2)
 " URL: https://github.com/ericpruitt/tmux.vim/
 " Maintainer: Eric Pruitt <eric.pruitt@gmail.com>
 " License: 2-Clause BSD (http://opensource.org/licenses/BSD-2-Clause)
@@ -14,7 +14,7 @@
 set cpo&vim
 
 let b:current_syntax = "tmux"
-setlocal iskeyword+=-
+syntax iskeyword @,48-57,_,192-255,-
 syntax case match
 
 syn keyword tmuxAction  none any current other
@@ -24,7 +24,7 @@
 
 syn match tmuxColour            /\<colour[0-9]\+/      display
 syn match tmuxKey               /\(C-\|M-\|\^\)\+\S\+/ display
-syn match tmuxNumber            /\d\+/                 display
+syn match tmuxNumber            /\<\d\+\>/             display
 syn match tmuxFlags             /\s-\a\+/              display
 syn match tmuxVariable          /\w\+=/                display
 syn match tmuxVariableExpansion /\${\=\w\+}\=/         display
@@ -62,30 +62,30 @@
 endfor
 
 syn keyword tmuxOptions
-\ buffer-limit command-alias default-terminal escape-time exit-unattached
-\ focus-events history-file message-limit set-clipboard terminal-overrides
-\ assume-paste-time base-index bell-action bell-on-alert default-command
+\ buffer-limit command-alias default-terminal escape-time exit-empty
+\ activity-action assume-paste-time base-index bell-action default-command
 \ default-shell destroy-unattached detach-on-destroy
 \ display-panes-active-colour display-panes-colour display-panes-time
-\ display-time history-limit key-table lock-after-time lock-command
-\ message-attr message-bg message-command-attr message-command-bg
-\ message-command-fg message-command-style message-fg message-style mouse
-\ prefix prefix2 renumber-windows repeat-time set-titles set-titles-string
+\ display-time exit-unattached focus-events history-file history-limit
+\ key-table lock-after-time lock-command message-attr message-bg
+\ message-command-attr message-command-bg message-command-fg
+\ message-command-style message-fg message-limit message-style mouse
+\ aggressive-resize allow-rename alternate-screen automatic-rename
+\ automatic-rename-format clock-mode-colour clock-mode-style force-height
+\ force-width main-pane-height main-pane-width mode-attr mode-bg mode-fg
+\ mode-keys mode-style monitor-activity monitor-bell monitor-silence
+\ other-pane-height other-pane-width pane-active-border-bg
+\ pane-active-border-fg pane-active-border-style pane-base-index
+\ pane-border-bg pane-border-fg pane-border-format pane-border-status
+\ pane-border-style prefix prefix2 remain-on-exit renumber-windows
+\ repeat-time set-clipboard set-titles set-titles-string silence-action
 \ status status-attr status-bg status-fg status-interval status-justify
 \ status-keys status-left status-left-attr status-left-bg status-left-fg
 \ status-left-length status-left-style status-position status-right
 \ status-right-attr status-right-bg status-right-fg status-right-length
-\ status-right-style status-style update-environment visual-activity
-\ visual-bell visual-silence word-separators aggressive-resize allow-rename
-\ alternate-screen automatic-rename automatic-rename-format
-\ clock-mode-colour clock-mode-style force-height force-width
-\ main-pane-height main-pane-width mode-attr mode-bg mode-fg mode-keys
-\ mode-style monitor-activity monitor-silence other-pane-height
-\ other-pane-width pane-active-border-bg pane-active-border-fg
-\ pane-active-border-style pane-base-index pane-border-bg pane-border-fg
-\ pane-border-format pane-border-status pane-border-style remain-on-exit
-\ synchronize-panes window-active-style window-style
-\ window-status-activity-attr window-status-activity-bg
+\ status-right-style status-style synchronize-panes terminal-overrides
+\ update-environment user-keys visual-activity visual-bell visual-silence
+\ window-active-style window-status-activity-attr window-status-activity-bg
 \ window-status-activity-fg window-status-activity-style window-status-attr
 \ window-status-bell-attr window-status-bell-bg window-status-bell-fg
 \ window-status-bell-style window-status-bg window-status-current-attr
@@ -93,32 +93,31 @@
 \ window-status-current-format window-status-current-style window-status-fg
 \ window-status-format window-status-last-attr window-status-last-bg
 \ window-status-last-fg window-status-last-style window-status-separator
-\ window-status-style wrap-search xterm-keys
+\ window-status-style window-style word-separators wrap-search xterm-keys
 
 syn keyword tmuxCommands
-\ attach-session attach bind-key bind break-pane breakp capture-pane
-\ capturep clear-history clearhist choose-buffer choose-client choose-tree
-\ choose-session choose-window command-prompt confirm-before confirm
-\ copy-mode clock-mode detach-client detach suspend-client suspendc
-\ display-message display display-panes displayp find-window findw if-shell
-\ if join-pane joinp move-pane movep kill-pane killp kill-server
-\ start-server start kill-session kill-window killw unlink-window unlinkw
-\ list-buffers lsb list-clients lsc list-keys lsk list-commands lscm
-\ list-panes lsp list-sessions ls list-windows lsw load-buffer loadb
-\ lock-server lock lock-session locks lock-client lockc move-window movew
-\ link-window linkw new-session new has-session has new-window neww
-\ paste-buffer pasteb pipe-pane pipep refresh-client refresh rename-session
-\ rename rename-window renamew resize-pane resizep respawn-pane respawnp
-\ respawn-window respawnw rotate-window rotatew run-shell run save-buffer
-\ saveb show-buffer showb select-layout selectl next-layout nextl
-\ previous-layout prevl select-pane selectp last-pane lastp select-window
-\ selectw next-window next previous-window prev last-window last send-keys
-\ send send-prefix set-buffer setb delete-buffer deleteb set-environment
-\ setenv set-hook show-hooks set-option set set-window-option setw
-\ show-environment showenv show-messages showmsgs show-options show
-\ show-window-options showw source-file source split-window splitw swap-pane
-\ swapp swap-window swapw switch-client switchc unbind-key unbind wait-for
-\ wait
+\ attach attach-session bind bind-key break-pane breakp capture-pane
+\ capturep choose-buffer choose-client choose-tree clear-history clearhist
+\ clock-mode command-prompt confirm confirm-before copy-mode detach
+\ detach-client display display-message display-panes displayp find-window
+\ findw if if-shell join-pane joinp kill-pane kill-server kill-session
+\ kill-window killp has-session has killw link-window linkw list-buffers
+\ list-clients list-commands list-keys list-panes list-sessions list-windows
+\ load-buffer loadb lock lock-client lock-server lock-session last-pane
+\ lastp lockc locks last-window last ls lsb delete-buffer deleteb lsc lscm
+\ lsk lsp lsw move-pane move-window movep movew new new-session new-window
+\ neww next next-layout next-window nextl paste-buffer pasteb pipe-pane
+\ pipep prev previous-layout previous-window prevl refresh refresh-client
+\ rename rename-session rename-window renamew resize-pane resizep
+\ respawn-pane respawn-window respawnp respawnw rotate-window rotatew run
+\ run-shell save-buffer saveb select-layout select-pane select-window
+\ selectl selectp selectw send send-keys send-prefix set set-buffer
+\ set-environment set-hook set-option set-window-option setb setenv setw
+\ show show-buffer show-environment show-hooks show-messages show-options
+\ show-window-options showb showenv showmsgs showw source source-file
+\ split-window splitw start start-server suspend-client suspendc swap-pane
+\ swap-window swapp swapw switch-client switchc unbind unbind-key
+\ unlink-window unlinkw wait wait-for
 
 let &cpo = s:original_cpo
 unlet! s:original_cpo s:bg s:i
