diff --git a/runtime/doc/autocmd.txt b/runtime/doc/autocmd.txt
index 25c5e0f..0c2fa52 100644
--- a/runtime/doc/autocmd.txt
+++ b/runtime/doc/autocmd.txt
@@ -1,4 +1,4 @@
-*autocmd.txt*   For Vim version 8.0.  Last change: 2018 Mar 15
+*autocmd.txt*   For Vim version 8.0.  Last change: 2018 Apr 19
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -1030,6 +1030,10 @@
 User				Never executed automatically.  To be used for
 				autocommands that are only executed with
 				":doautocmd".
+				Note that when `:doautocmd User MyEvent` is
+				used while there are no matching autocommands,
+				you will get an error.  If you don't want
+				that, define a dummy autocommand yourself.
 							*UserGettingBored*
 UserGettingBored		When the user presses the same key 42 times.
 				Just kidding! :-)
@@ -1074,9 +1078,10 @@
 				If the window is for another buffer, Vim
 				executes the BufEnter autocommands after the
 				WinEnter autocommands.
-				Note: When using ":split fname" the WinEnter
-				event is triggered after the split but before
-				the file "fname" is loaded.
+				Note: For split and tabpage commands the
+				WinEnter event is triggered after the split
+				or tab command but before the file is loaded.
+
 							*WinLeave*
 WinLeave			Before leaving a window.  If the window to be
 				entered next is for a different buffer, Vim
diff --git a/runtime/doc/change.txt b/runtime/doc/change.txt
index 8cca763..fe457c9 100644
--- a/runtime/doc/change.txt
+++ b/runtime/doc/change.txt
@@ -1,4 +1,4 @@
-*change.txt*    For Vim version 8.0.  Last change: 2017 Feb 12
+*change.txt*    For Vim version 8.0.  Last change: 2018 Apr 17
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -533,6 +533,7 @@
 If the 'smartindent' option is on, or 'cindent' is on and 'cinkeys' contains
 '#' with a zero value, shift right does not affect lines starting with '#'
 (these are supposed to be C preprocessor lines that must stay in column 1).
+This can be changed with the 'cino' option, see |cino-#|.
 
 When the 'expandtab' option is off (this is the default) Vim uses <Tab>s as
 much as possible to make the indent.  You can use ">><<" to replace an indent
diff --git a/runtime/doc/channel.txt b/runtime/doc/channel.txt
index 4e47ef1..f0d459b 100644
--- a/runtime/doc/channel.txt
+++ b/runtime/doc/channel.txt
@@ -1,4 +1,4 @@
-*channel.txt*      For Vim version 8.0.  Last change: 2017 Aug 11
+*channel.txt*      For Vim version 8.0.  Last change: 2018 Apr 18
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -55,7 +55,7 @@
 Common combination are:
 - Using a job connected through pipes in NL mode.  E.g., to run a style
   checker and receive errors and warnings.
-- Using a deamon, connecting over a socket in JSON mode.  E.g. to lookup
+- Using a daemon, connecting over a socket in JSON mode.  E.g. to lookup
   cross-references in a database.
 
 ==============================================================================
diff --git a/runtime/doc/develop.txt b/runtime/doc/develop.txt
index 2e00ccf..97823f3 100644
--- a/runtime/doc/develop.txt
+++ b/runtime/doc/develop.txt
@@ -1,4 +1,4 @@
-*develop.txt*   For Vim version 8.0.  Last change: 2018 Apr 17
+*develop.txt*   For Vim version 8.0.  Last change: 2018 Apr 18
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 35e7063..bcf14ee 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1,4 +1,4 @@
-*eval.txt*	For Vim version 8.0.  Last change: 2018 Mar 23
+*eval.txt*	For Vim version 8.0.  Last change: 2018 Apr 20
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -2438,8 +2438,10 @@
 term_sendkeys({buf}, {keys})	none	send keystrokes to a terminal
 term_setansicolors({buf}, {colors})
 				none	set ANSI palette in GUI color mode
-term_setkill({buf}, {how}) 	none	set signal to stop job in terminal
+term_setkill({buf}, {how})	none	set signal to stop job in terminal
 term_setrestore({buf}, {command}) none	set command to restore terminal
+term_setsize({buf}, {rows}, {cols})
+				none	set the size of a terminal
 term_start({cmd}, {options})	Job	open a terminal window and run a job
 term_wait({buf} [, {time}])	Number  wait for screen to be updated
 test_alloc_fail({id}, {countdown}, {repeat})
@@ -2466,7 +2468,7 @@
 toupper({expr})			String	the String {expr} switched to uppercase
 tr({src}, {fromstr}, {tostr})	String	translate chars of {src} in {fromstr}
 					to chars in {tostr}
-trim({text}[, {mask}]) 		String	trim characters in {mask} from {text}
+trim({text}[, {mask}])		String	trim characters in {mask} from {text}
 trunc({expr})			Float	truncate Float {expr}
 type({name})			Number	type of variable {name}
 undofile({name})		String	undo file name for {name}
@@ -6216,31 +6218,6 @@
 		characters.  nr2char(0) is a real NUL and terminates the
 		string, thus results in an empty string.
 
-option_restore({list})					*option_restore()*
-		Restore options previously saved by option_save().
-		When buffer-local options have been saved, this function must
-		be called when the same buffer is the current buffer.
-		When window-local options have been saved, this function must
-		be called when the same window is the current window.
-		When in the wrong buffer and/or window an error is given and
-		the local options won't be restored.
-		NOT IMPLEMENTED YET!
-
-option_save({list})					*option_save()*
-		Saves the options named in {list}.  The returned value can be
-		passed to option_restore().  Example: >
-			let s:saved_options = option_save([
-			    \ 'ignorecase',
-			    \ 'iskeyword',
-			    \ ])
-			 au <buffer> BufLeave *
-			    \ call option_restore(s:saved_options)
-<		The advantage over using `:let` is that global and local
-		values are handled and the script ID is restored, so that
-		`:verbose set` will show where the option was originally set,
-		not where it was restored.
-		NOT IMPLEMENTED YET!
-
 or({expr}, {expr})					*or()*
 		Bitwise OR on the two arguments.  The arguments are converted
 		to a number.  A List, Dict or Float argument causes an error.
@@ -8202,9 +8179,9 @@
 		   "term_name"	     name to use for the buffer name, instead
 				     of the first file name.
 		   "term_rows"	     vertical size to use for the terminal,
-				     instead of using 'termsize'
+				     instead of using 'termwinsize'
 		   "term_cols"	     horizontal size to use for the terminal,
-				     instead of using 'termsize'
+				     instead of using 'termwinsize'
 		   "vertical"	     split the window vertically
 		   "curwin"	     use the current window, do not split the
 				     window; fails if the current buffer
@@ -8422,7 +8399,7 @@
 
 		These colors are used in the GUI and in the terminal when
 		'termguicolors' is set.  When not using GUI colors (GUI mode
-		or |termguicolors|), the terminal window always uses the 16
+		or 'termguicolors'), the terminal window always uses the 16
 		ANSI colors of the underlying terminal.
 		{only available when compiled with the |+terminal| feature and
 		with GUI enabled and/or the |+termguicolors| feature}
@@ -8449,7 +8426,7 @@
 		Use "NONE" to not restore this window.
 		{only available when compiled with the |+terminal| feature}
 
-term_setsize({buf}, {rows}, {cols})			*term_setsize()*
+term_setsize({buf}, {rows}, {cols})		*term_setsize()* *E955*
 		Set the size of terminal {buf}. The size of the window
 		containing the terminal will also be adjusted, if possible.
 		If {rows} or {cols} is zero or negative, that dimension is not
@@ -8491,9 +8468,9 @@
 		   "term_name"	     name to use for the buffer name, instead
 				     of the command name.
 		   "term_rows"	     vertical size to use for the terminal,
-				     instead of using 'termsize'
+				     instead of using 'termwinsize'
 		   "term_cols"	     horizontal size to use for the terminal,
-				     instead of using 'termsize'
+				     instead of using 'termwinsize'
 		   "vertical"	     split the window vertically
 		   "curwin"	     use the current window, do not split the
 				     window; fails if the current buffer
diff --git a/runtime/doc/filetype.txt b/runtime/doc/filetype.txt
index f124079..a5f2a1c 100644
--- a/runtime/doc/filetype.txt
+++ b/runtime/doc/filetype.txt
@@ -1,4 +1,4 @@
-*filetype.txt*  For Vim version 8.0.  Last change: 2018 Feb 04
+*filetype.txt*  For Vim version 8.0.  Last change: 2018 Apr 18
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -319,6 +319,10 @@
 
 Note that the last one is the value of $VIMRUNTIME which has been expanded.
 
+Note that when using a plugin manager or |packages| many directories will be
+added to 'runtimepath'.  These plugins earch require their own directory,
+don't put them directly in ~/.vim/plugin.
+
 What if it looks like your plugin is not being loaded?  You can find out what
 happens when Vim starts up by using the |-V| argument: >
 
diff --git a/runtime/doc/index.txt b/runtime/doc/index.txt
index 3d0c8d6..1157e15 100644
--- a/runtime/doc/index.txt
+++ b/runtime/doc/index.txt
@@ -1,4 +1,4 @@
-*index.txt*     For Vim version 8.0.  Last change: 2017 Aug 02
+*index.txt*     For Vim version 8.0.  Last change: 2018 Apr 19
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -959,7 +959,7 @@
 |v_i{|		i{		   same as iB
 |v_i}|		i}		   same as iB
 |v_o|		o		   move cursor to other corner of area
-|v_r|		r		2  delete highlighted area and start insert
+|v_r|		r		2  replace highlighted area with a character
 |v_s|		s		2  delete highlighted area and start insert
 |v_u|		u		2  make highlighted area lowercase
 |v_v|		v		   make Visual mode characterwise or stop
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index fe400a5..c196d3b 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 8.0.  Last change: 2018 Apr 14
+*options.txt*	For Vim version 8.0.  Last change: 2018 Apr 18
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -7933,9 +7933,9 @@
 	Note that the "cterm" attributes are still used, not the "gui" ones.
 	NOTE: This option is reset when 'compatible' is set.
 
-						*'terminalscroll'* *'tlsl'*
-'terminalscroll' 'tlsl'	number	(default 10000)
-			global
+						*'termwinscroll'* *'twsl'*
+'termwinscroll' 'twsl'	number	(default 10000)
+			local to buffer
 			{not in Vi}
 			{not available when compiled without the
 			|+terminal| feature}
@@ -7943,21 +7943,21 @@
 	first 10% of the scrollback lines are deleted.  This is just to reduce
 	the memory usage.  See |Terminal-Normal|.
 
-						*'termkey'* *'tk'*
-'termkey' 'tk'		string	(default "")
+						*'termwinkey'* *'twk'*
+'termwinkey' 'twk'	string	(default "")
 			local to window
 			{not in Vi}
 	The key that starts a CTRL-W command in a terminal window.  Other keys
 	are sent to the job running in the window.
 	The <> notation can be used, e.g.: >
-		:set termkey=<C-L>
+		:set termwinkey=<C-L>
 <	The string must be one key stroke but can be multiple bytes.
 	When not set CTRL-W is used, so that CTRL-W : gets you to the command
-	line.  If 'termkey' is set to CTRL-L then CTRL-L : gets you to the
+	line.  If 'termwinkey' is set to CTRL-L then CTRL-L : gets you to the
 	command line.
 
-						*'termsize'* *'tms'*
-'termsize' 'tms'	string	(default "")
+						*'termwinsize'* *'tws'*
+'termwinsize' 'tws'	string	(default "")
 			local to window
 			{not in Vi}
 	Size of the |terminal| window.  Format: {rows}x{columns} or
diff --git a/runtime/doc/quickref.txt b/runtime/doc/quickref.txt
index 29000bf..8ec74e0 100644
--- a/runtime/doc/quickref.txt
+++ b/runtime/doc/quickref.txt
@@ -1,4 +1,4 @@
-*quickref.txt*  For Vim version 8.0.  Last change: 2018 Feb 11
+*quickref.txt*  For Vim version 8.0.  Last change: 2018 Apr 18
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -927,8 +927,9 @@
 'termbidi'	  'tbidi'   terminal takes care of bi-directionality
 'termencoding'	  'tenc'    character encoding used by the terminal
 'termguicolors'	  'tgc'     use GUI colors for the terminal
-'termkey'	  'tk'	    key that precedes a Vim command in a terminal
-'termsize'	  'tms'	    size of a terminal window
+'termwinkey'	  'twk'	    key that precedes a Vim command in a terminal
+'termwinscroll'   'twsl'    max number of scrollback lines in a terminal window
+'termwinsize'	  'tws'	    size of a terminal window
 'terse'			    shorten some messages
 'textauto'	  'ta'	    obsolete, use 'fileformats'
 'textmode'	  'tx'	    obsolete, use 'fileformat'
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 8562934..5895c05 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -1088,8 +1088,9 @@
 'termbidi'	options.txt	/*'termbidi'*
 'termencoding'	options.txt	/*'termencoding'*
 'termguicolors'	options.txt	/*'termguicolors'*
-'termkey'	options.txt	/*'termkey'*
-'termsize'	options.txt	/*'termsize'*
+'termwinkey'	options.txt	/*'termwinkey'*
+'termwinscroll'	options.txt	/*'termwinscroll'*
+'termwinsize'	options.txt	/*'termwinsize'*
 'terse'	options.txt	/*'terse'*
 'textauto'	options.txt	/*'textauto'*
 'textmode'	options.txt	/*'textmode'*
@@ -1105,10 +1106,8 @@
 'titlelen'	options.txt	/*'titlelen'*
 'titleold'	options.txt	/*'titleold'*
 'titlestring'	options.txt	/*'titlestring'*
-'tk'	options.txt	/*'tk'*
 'tl'	options.txt	/*'tl'*
 'tm'	options.txt	/*'tm'*
-'tms'	options.txt	/*'tms'*
 'to'	options.txt	/*'to'*
 'toolbar'	options.txt	/*'toolbar'*
 'toolbariconsize'	options.txt	/*'toolbariconsize'*
@@ -1129,6 +1128,9 @@
 'ttyscroll'	options.txt	/*'ttyscroll'*
 'ttytype'	options.txt	/*'ttytype'*
 'tw'	options.txt	/*'tw'*
+'twk'	options.txt	/*'twk'*
+'tws'	options.txt	/*'tws'*
+'twsl'	options.txt	/*'twsl'*
 'tx'	options.txt	/*'tx'*
 'uc'	options.txt	/*'uc'*
 'udf'	options.txt	/*'udf'*
@@ -1932,11 +1934,18 @@
 :AdaTagDir	ft_ada.txt	/*:AdaTagDir*
 :AdaTagFile	ft_ada.txt	/*:AdaTagFile*
 :AdaTypes	ft_ada.txt	/*:AdaTypes*
+:Arguments	terminal.txt	/*:Arguments*
+:Break	terminal.txt	/*:Break*
+:Clear	terminal.txt	/*:Clear*
 :CompilerSet	usr_41.txt	/*:CompilerSet*
+:Continue	terminal.txt	/*:Continue*
 :DiffOrig	diff.txt	/*:DiffOrig*
 :DoMatchParen	pi_paren.txt	/*:DoMatchParen*
+:Evaluate	terminal.txt	/*:Evaluate*
 :Explore	pi_netrw.txt	/*:Explore*
+:Finish	terminal.txt	/*:Finish*
 :GLVS	pi_getscript.txt	/*:GLVS*
+:Gdb	terminal.txt	/*:Gdb*
 :GetLatestVimScripts_dat	pi_getscript.txt	/*:GetLatestVimScripts_dat*
 :GnatFind	ft_ada.txt	/*:GnatFind*
 :GnatPretty	ft_ada.txt	/*:GnatPretty*
@@ -1961,11 +1970,14 @@
 :Ntree	pi_netrw.txt	/*:Ntree*
 :Nw	pi_netrw.txt	/*:Nw*
 :Nwrite	pi_netrw.txt	/*:Nwrite*
+:Over	terminal.txt	/*:Over*
 :P	various.txt	/*:P*
 :Pexplore	pi_netrw.txt	/*:Pexplore*
 :Print	various.txt	/*:Print*
+:Program	terminal.txt	/*:Program*
 :Rexplore	pi_netrw.txt	/*:Rexplore*
 :RmVimball	pi_vimball.txt	/*:RmVimball*
+:Run	terminal.txt	/*:Run*
 :RustEmitAsm	ft_rust.txt	/*:RustEmitAsm*
 :RustEmitIr	ft_rust.txt	/*:RustEmitIr*
 :RustExpand	ft_rust.txt	/*:RustExpand*
@@ -1974,14 +1986,19 @@
 :RustPlay	ft_rust.txt	/*:RustPlay*
 :RustRun	ft_rust.txt	/*:RustRun*
 :Sexplore	pi_netrw.txt	/*:Sexplore*
+:Source	terminal.txt	/*:Source*
+:Step	terminal.txt	/*:Step*
+:Stop	terminal.txt	/*:Stop*
 :TOhtml	syntax.txt	/*:TOhtml*
 :TarDiff	pi_tar.txt	/*:TarDiff*
 :Termdebug	terminal.txt	/*:Termdebug*
+:TermdebugCommand	terminal.txt	/*:TermdebugCommand*
 :Texplore	pi_netrw.txt	/*:Texplore*
 :UseVimball	pi_vimball.txt	/*:UseVimball*
 :Vexplore	pi_netrw.txt	/*:Vexplore*
 :VimballList	pi_vimball.txt	/*:VimballList*
 :Vimuntar	pi_tar.txt	/*:Vimuntar*
+:Winbar	terminal.txt	/*:Winbar*
 :X	editing.txt	/*:X*
 :XMLent	insert.txt	/*:XMLent*
 :XMLns	insert.txt	/*:XMLns*
@@ -4590,6 +4607,7 @@
 E952	autocmd.txt	/*E952*
 E953	eval.txt	/*E953*
 E954	options.txt	/*E954*
+E955	eval.txt	/*E955*
 E96	diff.txt	/*E96*
 E97	diff.txt	/*E97*
 E98	diff.txt	/*E98*
@@ -4831,6 +4849,8 @@
 Tcl	if_tcl.txt	/*Tcl*
 TermChanged	autocmd.txt	/*TermChanged*
 TermResponse	autocmd.txt	/*TermResponse*
+Terminal-Job	terminal.txt	/*Terminal-Job*
+Terminal-Normal	terminal.txt	/*Terminal-Normal*
 Terminal-mode	terminal.txt	/*Terminal-mode*
 TerminalOpen	autocmd.txt	/*TerminalOpen*
 TextChanged	autocmd.txt	/*TextChanged*
@@ -6499,6 +6519,7 @@
 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:terminal_ansi_colors	terminal.txt	/*g:terminal_ansi_colors*
 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*
@@ -7856,8 +7877,8 @@
 option-list	quickref.txt	/*option-list*
 option-summary	options.txt	/*option-summary*
 option-window	options.txt	/*option-window*
-option_restore()	eval.txt	/*option_restore()*
-option_save()	eval.txt	/*option_save()*
+option_restore()	todo.txt	/*option_restore()*
+option_save()	todo.txt	/*option_save()*
 options	options.txt	/*options*
 options-changed	version5.txt	/*options-changed*
 options-in-terminal	terminal.txt	/*options-in-terminal*
@@ -8919,6 +8940,7 @@
 term_dumpload()	eval.txt	/*term_dumpload()*
 term_dumpwrite()	eval.txt	/*term_dumpwrite()*
 term_getaltscreen()	eval.txt	/*term_getaltscreen()*
+term_getansicolors()	eval.txt	/*term_getansicolors()*
 term_getattr()	eval.txt	/*term_getattr()*
 term_getcursor()	eval.txt	/*term_getcursor()*
 term_getjob()	eval.txt	/*term_getjob()*
@@ -8931,6 +8953,7 @@
 term_list()	eval.txt	/*term_list()*
 term_scrape()	eval.txt	/*term_scrape()*
 term_sendkeys()	eval.txt	/*term_sendkeys()*
+term_setansicolors()	eval.txt	/*term_setansicolors()*
 term_setkill()	eval.txt	/*term_setkill()*
 term_setrestore()	eval.txt	/*term_setrestore()*
 term_setsize()	eval.txt	/*term_setsize()*
diff --git a/runtime/doc/terminal.txt b/runtime/doc/terminal.txt
index cce087f..59aeb97 100644
--- a/runtime/doc/terminal.txt
+++ b/runtime/doc/terminal.txt
@@ -1,4 +1,4 @@
-*terminal.txt*	For Vim version 8.0.  Last change: 2018 Apr 05
+*terminal.txt*	For Vim version 8.0.  Last change: 2018 Apr 20
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -80,16 +80,16 @@
 			evaluating an expression.
 	CTRL-W CTRL-C	ends the job, see below |t_CTRL-W_CTRL-C|
 
-See option 'termkey' for specifying another key instead of CTRL-W that
-will work like CTRL-W.  However, typing 'termkey' twice sends 'termkey' to
-the job.  For example:
-	'termkey' CTRL-W    move focus to the next window
-	'termkey' :	    enter an Ex command
-	'termkey' 'termkey' send 'termkey' to the job in the terminal
-	'termkey' .	    send a CTRL-W to the job in the terminal
-	'termkey' N	    go to terminal Normal mode, see below
-	'termkey' CTRL-N    same as CTRL-W N
-	'termkey' CTRL-C    same as |t_CTRL-W_CTRL-C|
+See option 'termwinkey' for specifying another key instead of CTRL-W that
+will work like CTRL-W.  However, typing 'termwinkey' twice sends 'termwinkey'
+to the job.  For example:
+	'termwinkey' CTRL-W    move focus to the next window
+	'termwinkey' :	       enter an Ex command
+	'termwinkey' 'termwinkey' send 'termwinkey' to the job in the terminal
+	'termwinkey' .	       send a CTRL-W to the job in the terminal
+	'termwinkey' N	       go to terminal Normal mode, see below
+	'termwinkey' CTRL-N    same as CTRL-W N
+	'termwinkey' CTRL-C    same as |t_CTRL-W_CTRL-C|
 							*t_CTRL-\_CTRL-N*
 The special key combination CTRL-\ CTRL-N can be used to switch to Normal
 mode, just like this works in any other mode.
@@ -125,7 +125,7 @@
 
 Size and color ~
 							*terminal-size-color*
-See option 'termsize' for controlling the size of the terminal window.
+See option 'termwinsize' for controlling the size of the terminal window.
 (TODO: scrolling when the terminal is larger than the window)
 
 The job running in the terminal can change the colors.  The default foreground
@@ -139,7 +139,7 @@
     hi Terminal ctermbg=lightgrey ctermfg=blue guibg=lightgrey guifg=blue
 <
 							*g:terminal_ansi_colors*
-In GUI mode or with |termguicolors|, the 16 ANSI colors used by default in new
+In GUI mode or with 'termguicolors', the 16 ANSI colors used by default in new
 terminal windows may be configured using the variable
 `g:terminal_ansi_colors`, which should be a list of 16 color names or
 hexadecimal color codes, similar to those accepted by |highlight-guifg|.  When
@@ -269,22 +269,22 @@
 							*terminal-resizing*
 The size of the terminal can be in one of three modes:
 
-1. The 'termsize' option is empty: The terminal size follows the window size.
-   The minimal size is 2 screen lines with 10 cells.
+1. The 'termwinsize' option is empty: The terminal size follows the window
+   size.  The minimal size is 2 screen lines with 10 cells.
 
-2. The 'termsize' option is "rows*cols", where "rows" is the minimal number of
-   screen rows and "cols" is the minimal number of cells.
+2. The 'termwinsize' option is "rows*cols", where "rows" is the minimal number
+   of screen rows and "cols" is the minimal number of cells.
 
-3. The 'termsize' option is "rowsXcols" (where the x is upper or lower case).
-   The terminal size is fixed to the specified number of screen lines and
-   cells.  If the window is bigger there will be unused empty space.
+3. The 'termwinsize' option is "rowsXcols" (where the x is upper or lower
+   case).  The terminal size is fixed to the specified number of screen lines
+   and cells.  If the window is bigger there will be unused empty space.
 
 If the window is smaller than the terminal size, only part of the terminal can
 be seen (the lower-left part).
 
 The |term_getsize()| function can be used to get the current size of the
 terminal.  |term_setsize()| can be used only when in the first or second mode,
-not when 'termsize' is "rowsXcols".
+not when 'termwinsize' is "rowsXcols".
 
 
 Terminal-Job and Terminal-Normal mode ~
@@ -294,7 +294,7 @@
 The terminal contents can change at any time.  This is called Terminal-Job
 mode.
 
-Use CTRL-W N (or 'termkey' N) to switch to Terminal-Normal mode.  Now the
+Use CTRL-W N (or 'termwinkey' N) to switch to Terminal-Normal mode.  Now the
 contents of the terminal window is under control of Vim, the job output is
 suspended.  CTRL-\ CTRL-N does the same.
 
@@ -316,7 +316,7 @@
 
 When the job outputs lines in the terminal, such that the contents scrolls off
 the top, those lines are remembered and can be seen in Terminal-Normal mode.
-The number of lines is limited by the 'terminalscroll' option. When going over
+The number of lines is limited by the 'termwinscroll' option. When going over
 this limit, the first 10% of the scrolled lins are deleted and are lost.
 
 
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 98304e8..9c26255 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 8.0.  Last change: 2018 Apr 05
+*todo.txt*      For Vim version 8.0.  Last change: 2018 Apr 20
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -36,53 +36,34 @@
 -------------------- Known bugs and current work -----------------------
 
 Terminal emulator window:
-- dump diff sometimes creates a different way of repeating.
-   Example: https://api.travis-ci.org/v3/job/359102504/log.txt
-  unclear why this can happen.
-- Passing 'term' as $TERM doesn't work in GUI.
 - Still some stuff to implement and bugs to fix, see src/terminal.c
-- GUI: problem with split window and sourcing the current buffer into python?
-    (Blay263, 2018 Mar 31)
-- Terminal debugger: need a way to (re) open the source window, where current
-  position is displayed.
-
-Mode message isn't updated on vertical split. (Alexei Averchenko, 2018 Feb 2,
-#2611)
-
-Patch to fix vimgrep adding to wrong quickfix list. (Yegappan, 2018 Mar 25)
 
 Problem with sudo. #2758
 
-Code refactoring, macro for message, #2729
-
-Fix for crash with non-dict argument to job options. (ichizok, #2765)
-
-Patch to enforce c89 compliance. (James McCoy, #2735)
-With fix for Mac from Kazunobu.
-
-Block insert doesn't work if the first line is auto-indented. (Christian
-Brabandt, 2018 Apr 4, #2778)
-
 Errors found with random data:
     heap-buffer-overflow in alist_add (#2472)
 
 Patch to avoid bad highlighting caused by #if. (ichizok, #2731)
 
-Patch to make mkdir() more like the shell command. (James McCoy, #2775)
-
-Implement option_save() and option_restore()?  Or remove the help.
+Patch to refactor qf_set_properties(). (Yegappan, Apr 17, #2812)
 
 Patch for static analysis warnings. (Christian Brabandt, 2018 Apr 1, #2770)
+Ther are more here: https://lgtm.com/projects/g/vim/vim/alerts/?mode=list
 
 Patch to refactor ex_helpgrep. (Yegappan, #2766, 2018 Mar 30)
 Also in email, take the one with a test.
 
+Allow for C99 features, decide which ones are OK:
+- "inline"
+- "long long"
+- flexible array members (change code to avoid FORTIFY_SOURCE problems)
+
 Looks like an error for inserting register makes ":file other" not work.
 (Tom M, 2018 Mar 28)  Reset did_emsg after inserting a register.
 Or at the top of the loop? (Apr 4)
 
 Patch to fix mouse pointer after :tselect. (Hirohito Higashi, #2709)
-How to reproduce the problem?
+How to reproduce the problem?  Remarks by Hirohito, Apr 8.
 
 Patch to avoid job killed when I/O is disconnected. (ichizok, #2734)
 
@@ -117,6 +98,10 @@
 
 Cursor in status line after search. (#2530)
 
+Add an option with file patterns, to be used when unloading a buffer: If there
+is a match, remove entries for the buffer from marks, jumplist, etc.  To be
+used for git temp files.
+
 Patch to fix that an empty buffer remains when using :argedit. (Christian,
 #2713)  Updated patch.
 
@@ -154,6 +139,10 @@
 When 'inchsearch' and 'hlsearch' are set /\v highlights everything.
 Also see #2337
 
+Python indenting: alternative way to indent arguments:
+http://orchistro.tistory.com/236
+Should be supported with a flag.
+
 Starting job with cwd option, when the directory does not exist, gives a
 confusing error message. (Wang Shidong, 2018 Jan 2, #2519)
 
@@ -188,6 +177,30 @@
 Patch to use the xdiff library instead of external diff. (Christian Brabandt,
 2018 Mar 20, #2732)
 
+Implement option_save() and option_restore():
+option_restore({list})					*option_restore()*
+		Restore options previously saved by option_save().
+		When buffer-local options have been saved, this function must
+		be called when the same buffer is the current buffer.
+		When window-local options have been saved, this function must
+		be called when the same window is the current window.
+		When in the wrong buffer and/or window an error is given and
+		the local options won't be restored.
+
+option_save({list})					*option_save()*
+		Saves the options named in {list}.  The returned value can be
+		passed to option_restore().  Example: >
+			let s:saved_options = option_save([
+			    \ 'ignorecase',
+			    \ 'iskeyword',
+			    \ ])
+			 au <buffer> BufLeave *
+			    \ call option_restore(s:saved_options)
+<		The advantage over using `:let` is that global and local
+		values are handled and the script ID is restored, so that
+		`:verbose set` will show where the option was originally set,
+		not where it was restored.
+
 "gvim --remote" from a directory with non-word characters changes the current
 directory (Paulo Marcel Coelho Arabic, 2017 Oct 30, #2266)
 Also see #1689.
@@ -255,6 +268,9 @@
 in #846)
 Doesn't work on Windows yet.  Not ready to included, hard coded paths.
 
+Win32 GUI: when running a fast timer, the cursor no longer blinks.
+Was reported: cursor blinks in terminal on widows with a timer. (xtal8, #2142)
+
 When a timer is running and typing CTRL-R on the command line, it is not
 redrawn properly. (xtal8, 2017 Oct 23, #2241)
 
@@ -581,9 +597,6 @@
 Update Oct 14: https://gist.github.com/mattn/d47e7d3bfe5ade4be86062b565a4bfca
 Update Aug 2017: #1954
 
-Characters deleted on completion. (Adrià Farrés, 2017 Apr 20, #1645)
-Remarks from Christian Brabandt (Apr 21)
-
 The TermResponse event is not triggered when a plugin has set 'eventignore' to
 "all".  Netrw does this. (Gary Johnson, 2017 Jan 24)
 Postpone the event until 'eventignore' is reset.
@@ -762,6 +775,8 @@
 
 Patch to support CamelCase for spell checking: See a lower-to-upper case
 change as a word boundary. (btucker-MPCData, 2016 Nov 6, #1235)
+patch for 'spellcamelcase' option: spellcheck each CamelCased word.
+(Ben Tucker, 2016 Dec 2)
 
 Idea from Sven: record sequence of keys.  Useful to show others what they are
 doing (look over the shoulder), and also to see what happened.
@@ -778,9 +793,6 @@
 
 Patch to order results from taglist(). (Duncan McDougall, 2016 Oct 25)
 
-patch for 'spellcamelcase' option: spellcheck each CamelCased word.
-(Ben Tucker, 2016 Dec 2)
-
 When using ":diffput" through a mapping, undo in the target buffer isn't
 synced.  (Ryan Carney, 2016 Sep 14)
 
@@ -1204,6 +1216,9 @@
 New OpenOffice spell files support this with ICONV.  But they are not
 compatible with Vim spell files.  The old files can no longer be downloaded.
 
+Spell checking: Add a feature to only consider two spaces after a dot to start
+a new sentence.  Don't give the capitalization error when there is one space.
+
 xterm should be able to pass focus changes to Vim, so that Vim can check for
 buffers that changed.  Perhaps in misc.c, function selectwindow().
 Xterm 224 supports it!
diff --git a/runtime/doc/usr_11.txt b/runtime/doc/usr_11.txt
index 09f01ab..31a53c0 100644
--- a/runtime/doc/usr_11.txt
+++ b/runtime/doc/usr_11.txt
@@ -1,4 +1,4 @@
-*usr_11.txt*	For Vim version 8.0.  Last change: 2010 Jul 20
+*usr_11.txt*	For Vim version 8.0.  Last change: 2018 Apr 13
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
@@ -234,7 +234,7 @@
 
 WHAT TO DO?					*swap-exists-choices*
 
-If dialogs are supported you will be asked to select one of five choices:
+If dialogs are supported you will be asked to select one of six choices:
 
   Swap file ".main.c.swp" already exists! ~
   [O]pen Read-Only, (E)dit anyway, (R)ecover, (Q)uit, (A)bort, (D)elete it: ~
diff --git a/runtime/doc/usr_41.txt b/runtime/doc/usr_41.txt
index 537eb37..bf324e6 100644
--- a/runtime/doc/usr_41.txt
+++ b/runtime/doc/usr_41.txt
@@ -1,4 +1,4 @@
-*usr_41.txt*	For Vim version 8.0.  Last change: 2018 Mar 03
+*usr_41.txt*	For Vim version 8.0.  Last change: 2018 Apr 11
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
@@ -988,6 +988,8 @@
 	term_getstatus()	get the status of a terminal
 	term_gettitle()		get the title of a terminal
 	term_gettty()		get the tty name of a terminal
+	term_setansicolors()	set 16 ANSI colors, used for GUI
+	term_getansicolors()	get 16 ANSI colors, used for GUI
 
 Timers:						*timer-functions*
 	timer_start()		create a timer
diff --git a/runtime/ftplugin/python.vim b/runtime/ftplugin/python.vim
index ee271ef..5c4a59b 100644
--- a/runtime/ftplugin/python.vim
+++ b/runtime/ftplugin/python.vim
@@ -3,7 +3,7 @@
 " Maintainer:	Tom Picton <tom@tompicton.co.uk>
 " Previous Maintainer: James Sully <sullyj3@gmail.com>
 " Previous Maintainer: Johannes Zellner <johannes@zellner.org>
-" Last Change:	Sun, 18 March 2018
+" Last Change:	Sun, 15 April 2018
 " https://github.com/tpict/vim-ftplugin-python
 
 if exists("b:did_ftplugin") | finish | endif
@@ -53,35 +53,35 @@
 let b:next_end='\v\S\n*(%$\|^(\s*\n*)*(class\|def\|async def)\|^\S)'
 let b:prev_end='\v\S\n*(^(\s*\n*)*(class\|def\|async def)\|^\S)'
 
-execute "nnoremap <silent> <buffer> ]] :call <SID>Python_jump('n', '". b:next_toplevel."', 'W')<cr>"
-execute "nnoremap <silent> <buffer> [[ :call <SID>Python_jump('n', '". b:prev_toplevel."', 'Wb')<cr>"
-execute "nnoremap <silent> <buffer> ][ :call <SID>Python_jump('n', '". b:next_endtoplevel."', 'W', 0)<cr>"
-execute "nnoremap <silent> <buffer> [] :call <SID>Python_jump('n', '". b:prev_endtoplevel."', 'Wb', 0)<cr>"
-execute "nnoremap <silent> <buffer> ]m :call <SID>Python_jump('n', '". b:next."', 'W')<cr>"
-execute "nnoremap <silent> <buffer> [m :call <SID>Python_jump('n', '". b:prev."', 'Wb')<cr>"
-execute "nnoremap <silent> <buffer> ]M :call <SID>Python_jump('n', '". b:next_end."', 'W', 0)<cr>"
-execute "nnoremap <silent> <buffer> [M :call <SID>Python_jump('n', '". b:prev_end."', 'Wb', 0)<cr>"
+execute "nnoremap <silent> <buffer> ]] :call <SID>Python_jump('n', '". b:next_toplevel."', 'W', v:count1)<cr>"
+execute "nnoremap <silent> <buffer> [[ :call <SID>Python_jump('n', '". b:prev_toplevel."', 'Wb', v:count1)<cr>"
+execute "nnoremap <silent> <buffer> ][ :call <SID>Python_jump('n', '". b:next_endtoplevel."', 'W', 0, v:count1)<cr>"
+execute "nnoremap <silent> <buffer> [] :call <SID>Python_jump('n', '". b:prev_endtoplevel."', 'Wb', 0, v:count1)<cr>"
+execute "nnoremap <silent> <buffer> ]m :call <SID>Python_jump('n', '". b:next."', 'W', v:count1)<cr>"
+execute "nnoremap <silent> <buffer> [m :call <SID>Python_jump('n', '". b:prev."', 'Wb', v:count1)<cr>"
+execute "nnoremap <silent> <buffer> ]M :call <SID>Python_jump('n', '". b:next_end."', 'W', 0, v:count1)<cr>"
+execute "nnoremap <silent> <buffer> [M :call <SID>Python_jump('n', '". b:prev_end."', 'Wb', 0, v:count1)<cr>"
 
-execute "onoremap <silent> <buffer> ]] :call <SID>Python_jump('o', '". b:next_toplevel."', 'W')<cr>"
-execute "onoremap <silent> <buffer> [[ :call <SID>Python_jump('o', '". b:prev_toplevel."', 'Wb')<cr>"
-execute "onoremap <silent> <buffer> ][ :call <SID>Python_jump('o', '". b:next_endtoplevel."', 'W', 0)<cr>"
-execute "onoremap <silent> <buffer> [] :call <SID>Python_jump('o', '". b:prev_endtoplevel."', 'Wb', 0)<cr>"
-execute "onoremap <silent> <buffer> ]m :call <SID>Python_jump('o', '". b:next."', 'W')<cr>"
-execute "onoremap <silent> <buffer> [m :call <SID>Python_jump('o', '". b:prev."', 'Wb')<cr>"
-execute "onoremap <silent> <buffer> ]M :call <SID>Python_jump('o', '". b:next_end."', 'W', 0)<cr>"
-execute "onoremap <silent> <buffer> [M :call <SID>Python_jump('o', '". b:prev_end."', 'Wb', 0)<cr>"
+execute "onoremap <silent> <buffer> ]] :call <SID>Python_jump('o', '". b:next_toplevel."', 'W', v:count1)<cr>"
+execute "onoremap <silent> <buffer> [[ :call <SID>Python_jump('o', '". b:prev_toplevel."', 'Wb', v:count1)<cr>"
+execute "onoremap <silent> <buffer> ][ :call <SID>Python_jump('o', '". b:next_endtoplevel."', 'W', 0, v:count1)<cr>"
+execute "onoremap <silent> <buffer> [] :call <SID>Python_jump('o', '". b:prev_endtoplevel."', 'Wb', 0, v:count1)<cr>"
+execute "onoremap <silent> <buffer> ]m :call <SID>Python_jump('o', '". b:next."', 'W', v:count1)<cr>"
+execute "onoremap <silent> <buffer> [m :call <SID>Python_jump('o', '". b:prev."', 'Wb', v:count1)<cr>"
+execute "onoremap <silent> <buffer> ]M :call <SID>Python_jump('o', '". b:next_end."', 'W', 0, v:count1)<cr>"
+execute "onoremap <silent> <buffer> [M :call <SID>Python_jump('o', '". b:prev_end."', 'Wb', 0, v:count1)<cr>"
 
-execute "xnoremap <silent> <buffer> ]] :call <SID>Python_jump('x', '". b:next_toplevel."', 'W')<cr>"
-execute "xnoremap <silent> <buffer> [[ :call <SID>Python_jump('x', '". b:prev_toplevel."', 'Wb')<cr>"
-execute "xnoremap <silent> <buffer> ][ :call <SID>Python_jump('x', '". b:next_endtoplevel."', 'W', 0)<cr>"
-execute "xnoremap <silent> <buffer> [] :call <SID>Python_jump('x', '". b:prev_endtoplevel."', 'Wb', 0)<cr>"
-execute "xnoremap <silent> <buffer> ]m :call <SID>Python_jump('x', '". b:next."', 'W')<cr>"
-execute "xnoremap <silent> <buffer> [m :call <SID>Python_jump('x', '". b:prev."', 'Wb')<cr>"
-execute "xnoremap <silent> <buffer> ]M :call <SID>Python_jump('x', '". b:next_end."', 'W', 0)<cr>"
-execute "xnoremap <silent> <buffer> [M :call <SID>Python_jump('x', '". b:prev_end."', 'Wb', 0)<cr>"
+execute "xnoremap <silent> <buffer> ]] :call <SID>Python_jump('x', '". b:next_toplevel."', 'W', v:count1)<cr>"
+execute "xnoremap <silent> <buffer> [[ :call <SID>Python_jump('x', '". b:prev_toplevel."', 'Wb', v:count1)<cr>"
+execute "xnoremap <silent> <buffer> ][ :call <SID>Python_jump('x', '". b:next_endtoplevel."', 'W', 0, v:count1)<cr>"
+execute "xnoremap <silent> <buffer> [] :call <SID>Python_jump('x', '". b:prev_endtoplevel."', 'Wb', 0, v:count1)<cr>"
+execute "xnoremap <silent> <buffer> ]m :call <SID>Python_jump('x', '". b:next."', 'W', v:count1)<cr>"
+execute "xnoremap <silent> <buffer> [m :call <SID>Python_jump('x', '". b:prev."', 'Wb', v:count1)<cr>"
+execute "xnoremap <silent> <buffer> ]M :call <SID>Python_jump('x', '". b:next_end."', 'W', 0, v:count1)<cr>"
+execute "xnoremap <silent> <buffer> [M :call <SID>Python_jump('x', '". b:prev_end."', 'Wb', 0, v:count1)<cr>"
 
 if !exists('*<SID>Python_jump')
-  fun! <SID>Python_jump(mode, motion, flags, ...) range
+  fun! <SID>Python_jump(mode, motion, flags, count, ...) range
       let l:startofline = (a:0 >= 1) ? a:1 : 1
 
       if a:mode == 'x'
@@ -92,7 +92,7 @@
           normal! 0
       endif
 
-      let cnt = v:count1
+      let cnt = a:count
       mark '
       while cnt > 0
           call search(a:motion, a:flags)
diff --git a/runtime/indent/tex.vim b/runtime/indent/tex.vim
index 1a4d8b1..a748cfb 100644
--- a/runtime/indent/tex.vim
+++ b/runtime/indent/tex.vim
@@ -2,7 +2,7 @@
 " Language:     LaTeX
 " Maintainer:   Yichao Zhou <broken.zhou AT gmail.com>
 " Created:      Sat, 16 Feb 2002 16:50:19 +0100
-" Version: 0.9.4
+" Version: 1.0.0
 "   Please email me if you found something I can do.  Comments, bug report and
 "   feature request are welcome.
 
@@ -62,6 +62,8 @@
 "               (*) Fix a bug between g:tex_noindent_env and g:tex_indent_items
 "                   Now g:tex_noindent_env='document\|verbatim\|itemize' (Emacs
 "                   style) is supported.  Thanks Miles Wheeler for reporting.
+"               2018/02/07 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Make indentation more smart in the normal mode
 "
 " }}}
 
@@ -91,19 +93,14 @@
 "   If this variable is set, item-environments are indented like Emacs does
 "   it, i.e., continuation lines are indented with a shiftwidth.
 "
-"   NOTE: I've already set the variable below; delete the corresponding line
-"   if you don't like this behaviour.
-"
-"   Per default, it is unset.
-"
-"              set                                unset
-"   ----------------------------------------------------------------
-"       \begin{itemize}                      \begin{itemize}
-"         \item blablabla                      \item blablabla
-"           bla bla bla                        bla bla bla
-"         \item blablabla                      \item blablabla
-"           bla bla bla                        bla bla bla
-"       \end{itemize}                        \end{itemize}
+"              set                      unset
+"   ------------------------------------------------------
+"       \begin{itemize}            \begin{itemize}
+"         \item blablabla            \item blablabla
+"           bla bla bla              bla bla bla
+"         \item blablabla            \item blablabla
+"           bla bla bla              bla bla bla
+"       \end{itemize}              \end{itemize}
 "
 "
 " * g:tex_items
@@ -290,8 +287,9 @@
         endif
     endif
 
-    if stay
-        " If there is no obvious indentation hint, we trust our user.
+    if stay && mode() == 'i'
+        " If there is no obvious indentation hint, and indentation is triggered
+        " in insert mode, we trust our user.
         if empty(cline)
             return ind
         else
diff --git a/runtime/syntax/javascript.vim b/runtime/syntax/javascript.vim
index 9589b19..a95ecac 100644
--- a/runtime/syntax/javascript.vim
+++ b/runtime/syntax/javascript.vim
@@ -9,6 +9,7 @@
 "		(ss) additional factoring of keywords, globals, and members
 " Last Change:	2012 Oct 05
 " 		2013 Jun 12: adjusted javaScriptRegexpString (Kevin Locke)
+" 		2018 Apr 14: adjusted javaScriptRegexpString (LongJohnCoder)
 
 " tuning parameters:
 " unlet javaScript_fold
@@ -37,7 +38,7 @@
 
 syn match   javaScriptSpecialCharacter "'\\.'"
 syn match   javaScriptNumber	       "-\=\<\d\+L\=\>\|0[xX][0-9a-fA-F]\+\>"
-syn region  javaScriptRegexpString     start=+/[^/*]+me=e-1 skip=+\\\\\|\\/+ end=+/[gim]\{0,2\}\s*$+ end=+/[gim]\{0,2\}\s*[;.,)\]}]+me=e-1 contains=@htmlPreproc oneline
+syn region  javaScriptRegexpString     start=+/[^/*]+me=e-1 skip=+\\\\\|\\/+ end=+/[gimuys]\{0,2\}\s*$+ end=+/[gimuys]\{0,2\}\s*[;.,)\]}]+me=e-1 contains=@htmlPreproc oneline
 
 syn keyword javaScriptConditional	if else switch
 syn keyword javaScriptRepeat		while for do in
diff --git a/runtime/syntax/neomuttrc.vim b/runtime/syntax/neomuttrc.vim
index ea9d1f0..7ff8987 100644
--- a/runtime/syntax/neomuttrc.vim
+++ b/runtime/syntax/neomuttrc.vim
@@ -1,10 +1,10 @@
 " Vim syntax file
 " Language:	NeoMutt setup files
 " Maintainer:	Guillaume Brogi <gui-gui@netcourrier.com>
-" Last Change:	2017 Oct 28
+" Last Change:	2018-03-25
 " Original version based on syntax/muttrc.vim
 
-" This file covers NeoMutt 20170912
+" This file covers NeoMutt 2018-03-23
 
 " quit when a syntax file was already loaded
 if exists("b:current_syntax")
@@ -134,7 +134,7 @@
 
 " Format escapes and conditionals
 syntax match muttrcFormatConditionals2 contained /[^?]*?/
-function s:escapesConditionals(baseName, sequence, alignment, secondary)
+function! s:escapesConditionals(baseName, sequence, alignment, secondary)
 	exec 'syntax match muttrc' . a:baseName . 'Escapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?\%(' . a:sequence . '\|%\)/'
 	if a:alignment
 		exec 'syntax match muttrc' . a:baseName . 'Escapes contained /%[>|*]./'
@@ -146,43 +146,40 @@
 	endif
 endfunction
 
-" flatcap compiled a list of formats here: https://pastebin.com/raw/5QXhiP6L
-" UPDATE
-" The following info was pulled from hdr_format_str in hdrline.c
-call s:escapesConditionals('IndexFormat', '[AaBbCcDdEeFfgHIiJKLlMmNnOPqrSsTtuvWXxYyZz(<[{]\|G[a-zA-Z]\+', 1, 1)
-" The following info was pulled from alias_format_str in addrbook.c
+" CHECKED 2018-04-18
+" Ref: index_format_str() in hdrline.c
+call s:escapesConditionals('IndexFormat', '[AaBbCcDdEeFfgHIiJKLlMmNnOPqRrSsTtuvWXxYyZz(<[{]\|G[a-zA-Z]\+', 1, 1)
+" Ref: alias_format_str() in addrbook.c
 syntax match muttrcAliasFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[afnrt%]/
-" The following info was pulled from newsgroup_format_str in browser.c
+" Ref: group_index_format_str() in browser.c
 call s:escapesConditionals('GroupIndexFormat', '[CdfMNns]', 1, 1)
-" The following info was pulled from cb_format_str in sidebar.c
+" Ref: sidebar_format_str() in sidebar.c
 call s:escapesConditionals('SidebarFormat', '[BdFLNnSt!]', 1, 1)
-" The following info was pulled from query_format_str in query.c
+" Ref: query_format_str() in query.c
 call s:escapesConditionals('QueryFormat', '[acent]', 0, 1)
-" The following info was pulled from mutt_attach_fmt in recvattach.c
+" Ref: attach_format_str() in recvattach.c
 call s:escapesConditionals('AttachFormat', '[CcDdeFfIMmnQsTtuX]', 1, 1)
-" The following info was pulled from compose_format_str in compose.c
+" Ref: compose_format_str() in compose.c
 syntax match muttrcComposeFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[ahlv%]/
 syntax match muttrcComposeFormatEscapes contained /%[>|*]./
-" The following info was pulled from folder_format_str in browser.c
-call s:escapesConditionals('FolderFormat', '[CDdfFglNstu]', 1, 0)
-" The following info was pulled from mix_entry_fmt in remailer.c
+" Ref: folder_format_str() in browser.c
+call s:escapesConditionals('FolderFormat', '[CDdFfglmNnstu]', 1, 0)
+" Ref: mix_format_str() in remailer.c
 call s:escapesConditionals('MixFormat', '[acns]', 0, 0)
-" The following info was pulled from crypt_entry_fmt in crypt-gpgme.c 
-" and pgp_entry_fmt in pgpkey.c (note that crypt_entry_fmt supports 
-" 'p', but pgp_entry_fmt does not).
-call s:escapesConditionals('PGPFormat', '[acfklnptu[]', 0, 0)
-" The following info was pulled from _mutt_fmt_pgp_command in 
-" pgpinvoke.c
-call s:escapesConditionals('PGPCmdFormat', '[afprs]', 0, 1)
-" The following info was pulled from status_format_str in status.c
-call s:escapesConditionals('StatusFormat', '[bdFfhLlMmnoPprSstuVu]', 1, 1)
-" This matches the documentation, but directly contradicts the code 
-" (according to the code, this should be identical to the 
-" muttrcPGPCmdFormatEscapes
-syntax match muttrcPGPGetKeysFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[acfklntu[%]/
-" The following info was pulled from _mutt_fmt_smime_command in 
-" smime.c
+" Ref: status_format_str() in status.c
+call s:escapesConditionals('StatusFormat', '[bdFfhLlMmnoPpRrSstuVv]', 1, 1)
+" Ref: fmt_smime_command() in ncrypt/smime.c
 call s:escapesConditionals('SmimeFormat', '[aCcdfiks]', 0, 1)
+" Ref: crypt_format_str() in ncrypt/crypt_gpgme.c
+" Ref: pgp_entry_fmt() in ncrypt/pgpkey.c
+" Note: crypt_format_str() supports 'p', but pgp_entry_fmt() does not
+call s:escapesConditionals('PGPFormat', '[acfklnptu[]', 0, 0)
+" Ref: fmt_pgp_command() ncrypt/pgpinvoke.c
+call s:escapesConditionals('PGPCmdFormat', '[afprs]', 0, 1)
+
+" This matches the documentation, but directly contradicts the code
+" (according to the code, this should be identical to the muttrcPGPCmdFormatEscapes
+syntax match muttrcPGPGetKeysFormatEscapes contained /%\%(\%(-\?[0-9]\+\)\?\%(\.[0-9]\+\)\?\)\?[:_]\?[acfklntu[%]/
 
 syntax region muttrcTimeEscapes contained start=+%{+ end=+}+ contains=muttrcStrftimeEscapes
 syntax region muttrcTimeEscapes contained start=+%\[+ end=+\]+ contains=muttrcStrftimeEscapes
@@ -190,36 +187,36 @@
 syntax region muttrcTimeEscapes contained start=+%<+ end=+>+ contains=muttrcStrftimeEscapes
 syntax region muttrcPGPTimeEscapes contained start=+%\[+ end=+\]+ contains=muttrcStrftimeEscapes
 
-syntax match muttrcVarEqualsAliasFmt contained skipwhite "=" nextgroup=muttrcAliasFormatStr
-syntax match muttrcVarEqualsAttachFmt contained skipwhite "=" nextgroup=muttrcAttachFormatStr
-syntax match muttrcVarEqualsComposeFmt contained skipwhite "=" nextgroup=muttrcComposeFormatStr
-syntax match muttrcVarEqualsFolderFmt contained skipwhite "=" nextgroup=muttrcFolderFormatStr
-syntax match muttrcVarEqualsIdxFmt contained skipwhite "=" nextgroup=muttrcIndexFormatStr
-syntax match muttrcVarEqualsGrpIdxFmt contained skipwhite "=" nextgroup=muttrcGroupIndexFormatStr
-syntax match muttrcVarEqualsMixFmt contained skipwhite "=" nextgroup=muttrcMixFormatStr
-syntax match muttrcVarEqualsPGPFmt contained skipwhite "=" nextgroup=muttrcPGPFormatStr
-syntax match muttrcVarEqualsQueryFmt contained skipwhite "=" nextgroup=muttrcQueryFormatStr
-syntax match muttrcVarEqualsPGPCmdFmt contained skipwhite "=" nextgroup=muttrcPGPCmdFormatStr
-syntax match muttrcVarEqualsSdbFmt contained skipwhite "=" nextgroup=muttrcSidebarFormatStr
-syntax match muttrcVarEqualsStatusFmt contained skipwhite "=" nextgroup=muttrcStatusFormatStr
+syntax match muttrcVarEqualsAliasFmt      contained skipwhite "=" nextgroup=muttrcAliasFormatStr
+syntax match muttrcVarEqualsAttachFmt     contained skipwhite "=" nextgroup=muttrcAttachFormatStr
+syntax match muttrcVarEqualsComposeFmt    contained skipwhite "=" nextgroup=muttrcComposeFormatStr
+syntax match muttrcVarEqualsFolderFmt     contained skipwhite "=" nextgroup=muttrcFolderFormatStr
+syntax match muttrcVarEqualsGrpIdxFmt     contained skipwhite "=" nextgroup=muttrcGroupIndexFormatStr
+syntax match muttrcVarEqualsIdxFmt        contained skipwhite "=" nextgroup=muttrcIndexFormatStr
+syntax match muttrcVarEqualsMixFmt        contained skipwhite "=" nextgroup=muttrcMixFormatStr
+syntax match muttrcVarEqualsPGPCmdFmt     contained skipwhite "=" nextgroup=muttrcPGPCmdFormatStr
+syntax match muttrcVarEqualsPGPFmt        contained skipwhite "=" nextgroup=muttrcPGPFormatStr
 syntax match muttrcVarEqualsPGPGetKeysFmt contained skipwhite "=" nextgroup=muttrcPGPGetKeysFormatStr
-syntax match muttrcVarEqualsSmimeFmt contained skipwhite "=" nextgroup=muttrcSmimeFormatStr
-syntax match muttrcVarEqualsStrftimeFmt contained skipwhite "=" nextgroup=muttrcStrftimeFormatStr
+syntax match muttrcVarEqualsQueryFmt      contained skipwhite "=" nextgroup=muttrcQueryFormatStr
+syntax match muttrcVarEqualsSdbFmt        contained skipwhite "=" nextgroup=muttrcSidebarFormatStr
+syntax match muttrcVarEqualsSmimeFmt      contained skipwhite "=" nextgroup=muttrcSmimeFormatStr
+syntax match muttrcVarEqualsStatusFmt     contained skipwhite "=" nextgroup=muttrcStatusFormatStr
+syntax match muttrcVarEqualsStrftimeFmt   contained skipwhite "=" nextgroup=muttrcStrftimeFormatStr
 
 syntax match muttrcVPrefix contained /[?&]/ nextgroup=muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
 
+" CHECKED 2018-04-18
 " List of the different screens in mutt
-" UPDATE
-syntax keyword muttrcMenu contained alias attach browser compose editor index pager postpone pgp mix query generic
+syntax keyword muttrcMenu contained alias attach browser compose editor generic index key_select_pgp key_select_smime mix pager pgp postpone query smime
 syntax match muttrcMenuList "\S\+" contained contains=muttrcMenu
 syntax match muttrcMenuCommas /,/ contained
 
+" CHECKED 2018-04-18
 " List of hooks in Commands in init.h
-" UPDATE
 syntax keyword muttrcHooks contained skipwhite
-			\ account-hook append-hook charset-hook
-			\ close-hook crypt-hook fcc-hook fcc-save-hook folder-hook iconv-hook mbox-hook
-			\ message-hook open-hook pgp-hook reply-hook save-hook send-hook send2-hook
+			\ account-hook append-hook close-hook crypt-hook fcc-hook fcc-save-hook
+			\ folder-hook iconv-hook mbox-hook message-hook open-hook pgp-hook
+			\ reply-hook save-hook send-hook send2-hook
 syntax keyword muttrcHooks skipwhite shutdown-hook startup-hook timeout-hook nextgroup=muttrcCommand
 
 syntax region muttrcSpamPattern	contained skipwhite keepend start=+'+ skip=+\\'+ end=+'+ contains=muttrcPattern nextgroup=muttrcString,muttrcStringNL
@@ -375,28 +372,29 @@
 syntax keyword muttrcMono	contained mono		skipwhite nextgroup=muttrcColorField,muttrcColorCompose
 syntax match   muttrcMonoLine	"^\s*mono\s\+\S\+"	skipwhite nextgroup=muttrcMonoAttrib contains=muttrcMono
 
+" CHECKED 2018-04-18
 " List of fields in Fields in color.c
-" UPDATE
-syntax keyword muttrcColorField skipwhite contained 
-			\ attach_headers attachment bold error hdrdefault index_author index_collapsed
-			\ index_date index_label index_number index_size index_subject index_tags
-			\ indicator markers message normal progress prompt quoted search sidebar_divider
+syntax keyword muttrcColorField skipwhite contained
+			\ attachment attach_headers body bold error hdrdefault header index
+			\ index_author index_collapsed index_date index_flags index_label
+			\ index_number index_size index_subject index_tag index_tags indicator
+			\ markers message normal progress prompt quoted search sidebar_divider
 			\ sidebar_flagged sidebar_highlight sidebar_indicator sidebar_new
 			\ sidebar_ordinary sidebar_spoolfile signature status tilde tree underline
-			\ body header index index_flags index_tag
 			\ nextgroup=muttrcColor
 syntax match   muttrcColorField	contained "\<quoted\d\=\>"
 
 syntax match muttrcColorCompose skipwhite contained /\s*compose\s*/ nextgroup=muttrcColorComposeField
+
+" CHECKED 2018-04-18
 " List of fields in ComposeFields in color.c
-" UPDATE
 syntax keyword muttrcColorComposeField skipwhite contained
-			\ header security_encrypt security_sign security_both security_none
+			\ header security_both security_encrypt security_none security_sign
 			\ nextgroup=muttrcColorFG,muttrcColorFGNL
 syntax region muttrcColorLine keepend start=/^\s*color\s\+/ skip=+\\$+ end=+$+ contains=muttrcColorKeyword,muttrcComment,muttrcUnHighlightSpace
 
 
-function s:boolQuadGen(type, vars, deprecated)
+function! s:boolQuadGen(type, vars, deprecated)
 	let l:novars = copy(a:vars)
 	call map(l:novars, '"no" . v:val')
 	let l:invvars = copy(a:vars)
@@ -414,104 +412,107 @@
 	exec 'syntax keyword muttrcVar' . l:type . ' skipwhite contained ' . join(l:invvars) . ' nextgroup=muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr'
 endfunction
 
+" CHECKED 2018-04-18
 " List of DT_BOOL in MuttVars in init.h
-" UPDATE
 call s:boolQuadGen('Bool', [
-			\ 'allow_8bit', 'allow_ansi', 'arrow_cursor', 'ascii_chars', 'askbcc', 'askcc',
-			\ 'ask_follow_up', 'ask_x_comment_to', 'attach_split', 'autoedit', 'auto_tag',
-			\ 'beep', 'beep_new', 'bounce_delivered', 'braille_friendly', 'check_mbox_size',
-			\ 'check_new', 'collapse_all', 'collapse_flagged', '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_headers', 'encode_from', 'fast_reply', 'fcc_clear', 'flag_safe',
-			\ 'followup_to', 'force_name', 'forward_decode', 'forward_decrypt',
-			\ 'forward_quote', 'forward_references', 'hdrs', 'header',
-			\ 'header_cache_compress', '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_idle', 'imap_list_subscribed', 'imap_passive',
-			\ 'imap_peek', 'imap_servernoise', 'implicit_autoview', 'include_onlyfirst',
-			\ 'keep_flagged', 'keywords_legacy', 'keywords_standard', 'mailcap_sanitize',
-			\ 'mail_check_recent', 'mail_check_stats', 'maildir_check_cur',
-			\ 'maildir_header_cache_verify', 'maildir_trash', 'markers', 'mark_old',
-			\ 'menu_move_off', 'menu_scroll', 'message_cache_clean', 'meta_key', 'metoo',
-			\ 'mh_purge', 'mime_forward_decode', 'mime_subject', 'mime_type_query_first',
-			\ 'narrow_tree', 'nm_record', 'nntp_listgroup', 'nntp_load_description',
-			\ 'pager_stop', 'pgp_auto_decode', 'pgp_autoinline', 'pgp_check_exit',
-			\ 'pgp_ignore_subkeys', 'pgp_long_ids', 'pgp_replyinline',
-			\ 'pgp_retainable_sigs', 'pgp_self_encrypt', 'pgp_show_unusable',
-			\ 'pgp_strict_enc', 'pgp_use_gpg_agent', 'pipe_decode', 'pipe_split',
-			\ 'pop_auth_try_all', 'pop_last', 'postpone_encrypt', 'print_decode',
-			\ 'print_split', 'prompt_after', 'read_only', 'reflow_space_quotes',
-			\ 'reflow_text', 'reply_self', 'reply_with_xorig', 'resolve',
-			\ 'resume_draft_files', 'resume_edited_draft_files', 'reverse_alias',
-			\ 'reverse_name', 'reverse_realname', 'rfc2047_parameters', 'save_address',
-			\ 'save_empty', 'save_name', 'save_unsubscribed', 'score', 'show_new_news',
-			\ 'show_only_unread', 'sidebar_folder_indent', 'sidebar_new_mail_only',
-			\ 'sidebar_next_new_wrap', 'sidebar_on_right', 'sidebar_short_path',
-			\ 'sidebar_visible', 'sig_dashes', 'sig_on_top', 'smart_wrap',
-			\ 'smime_ask_cert_label', 'smime_decrypt_use_default_key', 'smime_is_default',
-			\ 'smime_self_encrypt', 'sort_re', 'ssl_force_tls', 'ssl_use_sslv2',
-			\ 'ssl_use_sslv3', 'ssl_usesystemcerts', 'ssl_use_tlsv1', 'ssl_use_tlsv1_1',
-			\ 'ssl_use_tlsv1_2', 'ssl_verify_dates', 'ssl_verify_host',
-			\ 'ssl_verify_partial_chains', 'status_on_top', 'strict_threads', 'suspend',
-			\ 'text_flowed', 'thorough_search', 'thread_received', 'tilde', 'ts_enabled',
-			\ 'uncollapse_jump', 'uncollapse_new', 'use_8bitmime', 'use_domain',
-			\ 'use_envelope_from', 'use_from', 'use_ipv6', 'user_agent',
-			\ 'virtual_spoolfile', 'wait_key', 'weed', 'wrap_search', 'write_bcc',
-			\ 'x_comment_to'
+			\ 'allow_8bit', 'allow_ansi', 'arrow_cursor', 'ascii_chars', 'askbcc',
+			\ 'askcc', 'ask_follow_up', 'ask_x_comment_to', 'attach_split', 'autoedit',
+			\ 'auto_tag', 'beep', 'beep_new', 'bounce_delivered', 'braille_friendly',
+			\ 'change_folder_next', 'check_mbox_size', 'check_new', 'collapse_all',
+			\ 'collapse_flagged', '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_headers', 'encode_from', 'fast_reply',
+			\ 'fcc_clear', 'flag_safe', 'followup_to', 'force_name', 'forward_decode',
+			\ 'forward_decrypt', 'forward_quote', 'forward_references', 'hdrs',
+			\ 'header', 'header_cache_compress', '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_list_reply_to',
+			\ 'imap_check_subscribed', 'imap_idle', 'imap_list_subscribed',
+			\ 'imap_passive', 'imap_peek', 'imap_servernoise', 'implicit_autoview',
+			\ 'include_onlyfirst', 'keep_flagged', 'mailcap_sanitize',
+			\ 'maildir_check_cur', 'maildir_header_cache_verify', 'maildir_trash',
+			\ 'mail_check_recent', 'mail_check_stats', 'markers', 'mark_old',
+			\ 'menu_move_off', 'menu_scroll', 'message_cache_clean', 'meta_key',
+			\ 'metoo', 'mh_purge', 'mime_forward_decode', 'mime_subject',
+			\ 'mime_type_query_first', 'narrow_tree', 'nm_record', 'nntp_listgroup',
+			\ 'nntp_load_description', 'pager_stop', 'pgp_autoinline',
+			\ 'pgp_auto_decode', 'pgp_check_exit', 'pgp_ignore_subkeys', 'pgp_long_ids',
+			\ 'pgp_replyinline', 'pgp_retainable_sigs', 'pgp_self_encrypt',
+			\ 'pgp_show_unusable', 'pgp_strict_enc', 'pgp_use_gpg_agent', 'pipe_decode',
+			\ 'pipe_split', 'pop_auth_try_all', 'pop_last', 'postpone_encrypt',
+			\ 'print_decode', 'print_split', 'prompt_after', 'read_only',
+			\ 'reflow_space_quotes', 'reflow_text', 'reply_self', 'reply_with_xorig',
+			\ 'resolve', 'resume_draft_files', 'resume_edited_draft_files',
+			\ 'reverse_alias', 'reverse_name', 'reverse_realname', 'rfc2047_parameters',
+			\ 'save_address', 'save_empty', 'save_name', 'save_unsubscribed', 'score',
+			\ 'show_new_news', 'show_only_unread', 'sidebar_folder_indent',
+			\ 'sidebar_new_mail_only', 'sidebar_next_new_wrap', 'sidebar_on_right',
+			\ 'sidebar_short_path', 'sidebar_visible', 'sig_dashes', 'sig_on_top',
+			\ 'smart_wrap', 'smime_ask_cert_label', 'smime_decrypt_use_default_key',
+			\ 'smime_is_default', 'smime_self_encrypt', 'sort_re', 'ssl_force_tls',
+			\ 'ssl_usesystemcerts', 'ssl_use_sslv2', 'ssl_use_sslv3', 'ssl_use_tlsv1',
+			\ 'ssl_use_tlsv1_1', 'ssl_use_tlsv1_2', 'ssl_verify_dates',
+			\ 'ssl_verify_host', 'ssl_verify_partial_chains', 'status_on_top',
+			\ 'strict_threads', 'suspend', 'text_flowed', 'thorough_search',
+			\ 'thread_received', 'tilde', 'ts_enabled', 'uncollapse_jump',
+			\ 'uncollapse_new', 'user_agent', 'use_8bitmime', 'use_domain',
+			\ 'use_envelope_from', 'use_from', 'use_ipv6', 'virtual_spoolfile',
+			\ 'wait_key', 'weed', 'wrap_search', 'write_bcc', 'x_comment_to'
 			\ ], 0)
 
+" CHECKED 2018-04-18
 " Deprecated Bools
-" UPDATE
 " List of DT_SYNONYM synonyms of Bools in MuttVars in init.h
 call s:boolQuadGen('Bool', [
-			\ 'edit_hdrs', 'envelope_from', 'forw_decode', 'forw_decrypt', 'forw_quote',
-			\ 'pgp_autoencrypt', 'pgp_autosign', 'pgp_auto_traditional',
-			\ 'pgp_create_traditional', 'pgp_replyencrypt', 'pgp_replysign',
-			\ 'pgp_replysignencrypted', 'xterm_set_titles'
+			\ 'edit_hdrs', 'envelope_from', 'forw_decode', 'forw_decrypt',
+			\ 'forw_quote', 'ignore_linear_white_space', 'pgp_autoencrypt',
+			\ 'pgp_autosign', 'pgp_auto_traditional', 'pgp_create_traditional',
+			\ 'pgp_replyencrypt', 'pgp_replysign', 'pgp_replysignencrypted',
+			\ 'xterm_set_titles'
 			\ ], 1)
 
+" CHECKED 2018-04-18
 " List of DT_QUAD in MuttVars in init.h
-" UPDATE
 call s:boolQuadGen('Quad', [
 			\ 'abort_noattach', 'abort_nosubject', 'abort_unmodified', 'bounce',
 			\ 'catchup_newsgroup', 'copy', 'crypt_verify_sig', 'delete', 'fcc_attach',
 			\ 'followup_to_poster', 'forward_edit', 'honor_followup_to', 'include',
-			\ 'mime_forward', 'mime_forward_rest', 'move', 'pgp_encrypt_self',
-			\ 'pgp_mime_auto', 'pop_delete', 'pop_reconnect', 'post_moderated', 'postpone',
-			\ 'print', 'quit', 'recall', 'reply_to', 'smime_encrypt_self', 'ssl_starttls',
+			\ 'mime_forward', 'mime_forward_rest', 'move', 'pgp_mime_auto',
+			\ 'pop_delete', 'pop_reconnect', 'postpone', 'post_moderated', 'print',
+			\ 'quit', 'recall', 'reply_to', 'ssl_starttls'
 			\ ], 0)
 
+" CHECKED 2018-04-18
 " Deprecated Quads
-" UPDATE
 " List of DT_SYNONYM synonyms of Quads in MuttVars in init.h
 call s:boolQuadGen('Quad', [
-			\ 'mime_fwd', 'pgp_verify_sig'
+			\ 'mime_fwd', 'pgp_encrypt_self', 'pgp_verify_sig', 'smime_encrypt_self'
 			\ ], 1)
 
+" CHECKED 2018-04-18
 " List of DT_NUMBER in MuttVars in init.h
-" UPDATE
 syntax keyword muttrcVarNum	skipwhite contained
 			\ connect_timeout debug_level history imap_keepalive imap_pipeline_depth
-			\ imap_poll_timeout mail_check mail_check_stats_interval menu_context net_inc
-			\ nm_db_limit nm_open_timeout nm_query_window_current_position
+			\ imap_poll_timeout mail_check mail_check_stats_interval menu_context
+			\ net_inc nm_db_limit nm_open_timeout nm_query_window_current_position
 			\ nm_query_window_duration nntp_context nntp_poll pager_context
 			\ pager_index_lines pgp_timeout pop_checkinterval read_inc reflow_wrap
-			\ save_history score_threshold_delete score_threshold_flag score_threshold_read
-			\ search_context sendmail_wait sidebar_width skip_quoted_offset sleep_time
-			\ smime_timeout ssl_min_dh_prime_bits time_inc timeout wrap wrap_headers
-			\ wrapmargin write_inc
+			\ save_history score_threshold_delete score_threshold_flag
+			\ score_threshold_read search_context sendmail_wait sidebar_component_depth
+			\ sidebar_width skip_quoted_offset sleep_time smime_timeout
+			\ ssl_min_dh_prime_bits timeout time_inc wrap wrap_headers write_inc
+			\ nextgroup=muttrcSetNumAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
+syntax keyword muttrcVarDeprecatedNum	contained skipwhite
+			\ wrapmargin
 			\ nextgroup=muttrcSetNumAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
 
+" CHECKED 2018-04-18
 " List of DT_STRING in MuttVars in init.h
-" UPDATE
 " Special cases first, and all the rest at the end
-" A lot of special cases are format, flatcap compiled a list here https://pastebin.com/raw/5QXhiP6L
 " Formats themselves must be updated in their respective groups
 " See s:escapesConditionals
 syntax match muttrcVarStr	contained skipwhite 'my_[a-zA-Z0-9_]\+' nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
@@ -523,49 +524,52 @@
 " Deprecated format
 syntax keyword muttrcVarDeprecatedStr	contained skipwhite hdr_format msg_format nextgroup=muttrcVarEqualsIdxFmt
 syntax keyword muttrcVarStr	contained skipwhite mix_entry_format nextgroup=muttrcVarEqualsMixFmt
-syntax keyword muttrcVarStr	contained skipwhite 
-			\ pgp_decode_command pgp_verify_command pgp_decrypt_command
-			\ pgp_clearsign_command pgp_sign_command pgp_encrypt_sign_command
-			\ pgp_encrypt_only_command pgp_import_command pgp_export_command
-			\ pgp_verify_key_command pgp_list_secring_command pgp_list_pubring_command
+syntax keyword muttrcVarStr	contained skipwhite
+			\ pgp_clearsign_command pgp_decode_command pgp_decrypt_command
+			\ pgp_encrypt_only_command pgp_encrypt_sign_command pgp_export_command
+			\ pgp_import_command pgp_list_pubring_command pgp_list_secring_command
+			\ pgp_sign_command pgp_verify_command pgp_verify_key_command
 			\ nextgroup=muttrcVarEqualsPGPCmdFmt
 syntax keyword muttrcVarStr	contained skipwhite pgp_entry_format nextgroup=muttrcVarEqualsPGPFmt
 syntax keyword muttrcVarStr	contained skipwhite pgp_getkeys_command nextgroup=muttrcVarEqualsPGPGetKeysFmt
 syntax keyword muttrcVarStr	contained skipwhite query_format nextgroup=muttrcVarEqualsQueryFmt
 syntax keyword muttrcVarStr	contained skipwhite
-			\ smime_decrypt_command smime_verify_command smime_verify_opaque_command
-			\ smime_sign_command smime_sign_opaque_command smime_encrypt_command
-			\ smime_pk7out_command smime_get_cert_command smime_get_signer_cert_command
-			\ smime_import_cert_command smime_get_cert_email_command
+			\ smime_decrypt_command smime_encrypt_command smime_get_cert_command
+			\ smime_get_cert_email_command smime_get_signer_cert_command
+			\ smime_import_cert_command smime_pk7out_command smime_sign_command
+			\ smime_verify_command smime_verify_opaque_command
 			\ nextgroup=muttrcVarEqualsSmimeFmt
 syntax keyword muttrcVarStr	contained skipwhite ts_icon_format ts_status_format status_format nextgroup=muttrcVarEqualsStatusFmt
 " Deprecated format
 syntax keyword muttrcVarDeprecatedStr	contained skipwhite xterm_icon xterm_title nextgroup=muttrcVarEqualsStatusFmt
 syntax keyword muttrcVarStr	contained skipwhite date_format nextgroup=muttrcVarEqualsStrftimeFmt
-syntax keyword muttrcVarStr	contained skipwhite group_index_format nextgroup=muttrcVarEqualsGrpIdxFmt 
+syntax keyword muttrcVarStr	contained skipwhite group_index_format nextgroup=muttrcVarEqualsGrpIdxFmt
 syntax keyword muttrcVarStr	contained skipwhite sidebar_format nextgroup=muttrcVarEqualsSdbFmt
 syntax keyword muttrcVarStr	contained skipwhite
 			\ assumed_charset attach_charset attach_sep attribution_locale charset
-			\ config_charset content_type default_hook dsn_notify dsn_return empty_subject
-			\ escape forward_attribution_intro forward_attribution_trailer forward_format
-			\ header_cache_pagesize hostname imap_authenticators imap_delim_chars
-			\ imap_headers imap_login imap_pass imap_user indent_string mailcap_path
-			\ mark_macro_prefix mh_seq_flagged mh_seq_replied mh_seq_unseen
-			\ mime_type_query_command newsgroups_charset news_server nm_default_uri
-			\ nm_exclude_tags nm_hidden_tags nm_query_type nm_query_window_current_search
-			\ nm_query_window_timebase nm_record_tags nm_unread_tag nntp_authenticators
-			\ nntp_pass nntp_user pgp_self_encrypt_as pgp_sign_as pipe_sep
-			\ pop_authenticators pop_host pop_pass pop_user post_indent_string
-			\ postpone_encrypt_as preconnect realname send_charset
+			\ config_charset content_type default_hook dsn_notify dsn_return
+			\ empty_subject escape forward_attribution_intro forward_attribution_trailer
+			\ forward_format header_cache_pagesize hidden_tags hostname
+			\ imap_authenticators imap_delim_chars imap_headers imap_login imap_pass
+			\ imap_user indent_string mailcap_path mark_macro_prefix mh_seq_flagged
+			\ mh_seq_replied mh_seq_unseen mime_type_query_command newsgroups_charset
+			\ news_server nm_default_uri nm_exclude_tags nm_query_type
+			\ nm_query_window_current_search nm_query_window_timebase nm_record_tags
+			\ nm_unread_tag nntp_authenticators nntp_pass nntp_user pgp_default_key
+			\ pgp_sign_as pipe_sep pop_authenticators pop_host pop_pass pop_user
+			\ postpone_encrypt_as post_indent_string preconnect realname send_charset
 			\ show_multipart_alternative sidebar_delim_chars sidebar_divider_char
 			\ sidebar_indent_string simple_search smime_default_key smime_encrypt_with
-			\ smime_self_encrypt_as smime_sign_digest_alg smtp_authenticators smtp_pass
-			\ smtp_url spam_separator ssl_ciphers tunnel xlabel_delimiter
+			\ smime_sign_as smime_sign_digest_alg smtp_authenticators smtp_pass smtp_url
+			\ spam_separator ssl_ciphers tunnel
 			\ nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
 " Deprecated strings
 syntax keyword muttrcVarDeprecatedStr	contained skipwhite
-			\ forw_format indent_str post_indent_str smime_sign_as
+			\ forw_format indent_str pgp_self_encrypt_as post_indent_str
+			\ smime_self_encrypt_as
 			\ nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
+
+" CHECKED 2018-04-18
 " List of DT_ADDRESS
 syntax keyword muttrcVarStr	contained skipwhite envelope_from_address from nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
 " List of DT_HCACHE
@@ -574,6 +578,8 @@
 syntax keyword muttrcVarStr	contained skipwhite mbox_type nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
 " List of DT_MBTABLE
 syntax keyword muttrcVarStr	contained skipwhite flag_chars from_chars status_chars to_chars nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
+
+" CHECKED 2018-04-18
 " List of DT_PATH
 syntax keyword muttrcVarStr	contained skipwhite
 			\ alias_file certificate_file debug_file display_filter editor entropy_file
@@ -583,20 +589,24 @@
 			\ smime_certificates smime_keys spoolfile ssl_ca_certificates_file
 			\ ssl_client_cert tmpdir trash visual
 			\ nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
-" List of deprecated DT_PATH
-syntax keyword muttrcVarDeprecatedStr	contained skipwhite print_cmd nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
+
+" CHECKED 2018-04-18
 " List of DT_REGEX
 syntax keyword muttrcVarStr	contained skipwhite
-			\ attach_keyword gecos_mask mask pgp_decryption_okay pgp_good_sign quote_regexp
-			\ reply_regexp smileys
+			\ abort_noattach_regex gecos_mask mask pgp_decryption_okay pgp_good_sign
+			\ quote_regex reply_regex smileys
 			\ nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
+" List of deprecated DT_PATH
+syntax keyword muttrcVarDeprecatedStr	contained skipwhite print_cmd nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
+" List of deprecated DT_REGEX
+syntax keyword muttrcVarDeprecatedStr	contained skipwhite abort_noattach_regexp attach_keyword quote_regexp reply_regexp nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
 " List of DT_SORT
 syntax keyword muttrcVarStr	contained skipwhite
 			\ pgp_sort_keys sidebar_sort_method sort sort_alias sort_aux sort_browser
 			\ nextgroup=muttrcSetStrAssignment,muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
 
+" CHECKED 2018-04-18
 " List of commands in Commands in init.h
-" UPDATE
 " Remember to remove hooks, they have already been dealt with
 syntax keyword muttrcCommand	skipwhite charset-hook nextgroup=muttrcRXString
 syntax keyword muttrcCommand	skipwhite unhook nextgroup=muttrcHooks
@@ -609,19 +619,16 @@
 syntax keyword muttrcCommand	skipwhite set unset reset toggle nextgroup=muttrcVPrefix,muttrcVarBool,muttrcVarQuad,muttrcVarNum,muttrcVarStr,muttrcVarDeprecatedBool,muttrcVarDeprecatedQuad,muttrcVarDeprecatedStr
 syntax keyword muttrcCommand	skipwhite exec nextgroup=muttrcFunction
 syntax keyword muttrcCommand	skipwhite
-			\ alternative_order attachments auto_view hdr_order ifdef ifndef ignore lua
-			\ lua-source mailboxes mailto_allow mime_lookup my_hdr push score setenv
-			\ sidebar_whitelist source subjectrx tag-formats tag-transforms
-			\ unalternative_order unattachments unauto_view uncolor unhdr_order unignore
-			\ unmailboxes unmailto_allow unmime_lookup unmono unmy_hdr unscore unsetenv
-			\ unsidebar_whitelist unsubjectrx unvirtual-mailboxes virtual-mailboxes
+			\ alternative_order attachments auto_view finish hdr_order ifdef ifndef
+			\ ignore lua lua-source mailboxes mailto_allow mime_lookup my_hdr push score
+			\ setenv sidebar_whitelist source subjectrx subscribe-to tag-formats
+			\ tag-transforms unalternative_order unattachments unauto_view uncolor
+			\ unhdr_order unignore unmailboxes unmailto_allow unmime_lookup unmono
+			\ unmy_hdr unscore unsetenv unsidebar_whitelist unsubjectrx unsubscribe-from
+			\ unvirtual-mailboxes virtual-mailboxes
 
+" CHECKED 2018-04-18
 " List of functions in functions.h
-" UPDATE
-syntax match muttrcFunction contained "\<accept\>"
-syntax match muttrcFunction contained "\<append\>"
-syntax match muttrcFunction contained "\<attach-file\>"
-syntax match muttrcFunction contained "\<attach-key\>"
 syntax match muttrcFunction contained "\<accept\>"
 syntax match muttrcFunction contained "\<append\>"
 syntax match muttrcFunction contained "\<attach-file\>"
@@ -632,8 +639,8 @@
 syntax match muttrcFunction contained "\<backward-char\>"
 syntax match muttrcFunction contained "\<backward-word\>"
 syntax match muttrcFunction contained "\<bol\>"
-syntax match muttrcFunction contained "\<bottom\>"
 syntax match muttrcFunction contained "\<bottom-page\>"
+syntax match muttrcFunction contained "\<bottom\>"
 syntax match muttrcFunction contained "\<bounce-message\>"
 syntax match muttrcFunction contained "\<break-thread\>"
 syntax match muttrcFunction contained "\<buffy-cycle\>"
@@ -643,10 +650,10 @@
 syntax match muttrcFunction contained "\<chain-next\>"
 syntax match muttrcFunction contained "\<chain-prev\>"
 syntax match muttrcFunction contained "\<change-dir\>"
-syntax match muttrcFunction contained "\<change-folder\>"
 syntax match muttrcFunction contained "\<change-folder-readonly\>"
-syntax match muttrcFunction contained "\<change-newsgroup\>"
+syntax match muttrcFunction contained "\<change-folder\>"
 syntax match muttrcFunction contained "\<change-newsgroup-readonly\>"
+syntax match muttrcFunction contained "\<change-newsgroup\>"
 syntax match muttrcFunction contained "\<change-vfolder\>"
 syntax match muttrcFunction contained "\<check-new\>"
 syntax match muttrcFunction contained "\<check-traditional-pgp\>"
@@ -654,8 +661,8 @@
 syntax match muttrcFunction contained "\<collapse-all\>"
 syntax match muttrcFunction contained "\<collapse-parts\>"
 syntax match muttrcFunction contained "\<collapse-thread\>"
-syntax match muttrcFunction contained "\<complete\>"
 syntax match muttrcFunction contained "\<complete-query\>"
+syntax match muttrcFunction contained "\<complete\>"
 syntax match muttrcFunction contained "\<compose-to-sender\>"
 syntax match muttrcFunction contained "\<copy-file\>"
 syntax match muttrcFunction contained "\<copy-message\>"
@@ -668,7 +675,6 @@
 syntax match muttrcFunction contained "\<decode-save\>"
 syntax match muttrcFunction contained "\<decrypt-copy\>"
 syntax match muttrcFunction contained "\<decrypt-save\>"
-syntax match muttrcFunction contained "\<delete\>"
 syntax match muttrcFunction contained "\<delete-char\>"
 syntax match muttrcFunction contained "\<delete-entry\>"
 syntax match muttrcFunction contained "\<delete-mailbox\>"
@@ -676,13 +682,13 @@
 syntax match muttrcFunction contained "\<delete-pattern\>"
 syntax match muttrcFunction contained "\<delete-subthread\>"
 syntax match muttrcFunction contained "\<delete-thread\>"
+syntax match muttrcFunction contained "\<delete\>"
 syntax match muttrcFunction contained "\<detach-file\>"
 syntax match muttrcFunction contained "\<display-address\>"
 syntax match muttrcFunction contained "\<display-filename\>"
 syntax match muttrcFunction contained "\<display-message\>"
 syntax match muttrcFunction contained "\<display-toggle-weed\>"
 syntax match muttrcFunction contained "\<downcase-word\>"
-syntax match muttrcFunction contained "\<edit\>"
 syntax match muttrcFunction contained "\<edit-bcc\>"
 syntax match muttrcFunction contained "\<edit-cc\>"
 syntax match muttrcFunction contained "\<edit-description\>"
@@ -696,11 +702,14 @@
 syntax match muttrcFunction contained "\<edit-message\>"
 syntax match muttrcFunction contained "\<edit-mime\>"
 syntax match muttrcFunction contained "\<edit-newsgroups\>"
+syntax match muttrcFunction contained "\<edit-or-view-raw-message\>"
+syntax match muttrcFunction contained "\<edit-raw-message\>"
 syntax match muttrcFunction contained "\<edit-reply-to\>"
 syntax match muttrcFunction contained "\<edit-subject\>"
 syntax match muttrcFunction contained "\<edit-to\>"
 syntax match muttrcFunction contained "\<edit-type\>"
 syntax match muttrcFunction contained "\<edit-x-comment-to\>"
+syntax match muttrcFunction contained "\<edit\>"
 syntax match muttrcFunction contained "\<end-cond\>"
 syntax match muttrcFunction contained "\<enter-command\>"
 syntax match muttrcFunction contained "\<enter-mask\>"
@@ -723,11 +732,13 @@
 syntax match muttrcFunction contained "\<get-message\>"
 syntax match muttrcFunction contained "\<get-parent\>"
 syntax match muttrcFunction contained "\<goto-folder\>"
+syntax match muttrcFunction contained "\<goto-parent\>"
 syntax match muttrcFunction contained "\<group-reply\>"
 syntax match muttrcFunction contained "\<half-down\>"
 syntax match muttrcFunction contained "\<half-up\>"
 syntax match muttrcFunction contained "\<help\>"
 syntax match muttrcFunction contained "\<history-down\>"
+syntax match muttrcFunction contained "\<history-search\>"
 syntax match muttrcFunction contained "\<history-up\>"
 syntax match muttrcFunction contained "\<imap-fetch-mail\>"
 syntax match muttrcFunction contained "\<imap-logout-all\>"
@@ -739,29 +750,32 @@
 syntax match muttrcFunction contained "\<kill-line\>"
 syntax match muttrcFunction contained "\<kill-word\>"
 syntax match muttrcFunction contained "\<last-entry\>"
-syntax match muttrcFunction contained "\<limit\>"
 syntax match muttrcFunction contained "\<limit-current-thread\>"
+syntax match muttrcFunction contained "\<limit\>"
 syntax match muttrcFunction contained "\<link-threads\>"
 syntax match muttrcFunction contained "\<list-reply\>"
-syntax match muttrcFunction contained "\<mail\>"
 syntax match muttrcFunction contained "\<mail-key\>"
+syntax match muttrcFunction contained "\<mail\>"
 syntax match muttrcFunction contained "\<mark-as-new\>"
 syntax match muttrcFunction contained "\<mark-message\>"
 syntax match muttrcFunction contained "\<middle-page\>"
 syntax match muttrcFunction contained "\<mix\>"
-syntax match muttrcFunction contained "\<modify-labels\>"
 syntax match muttrcFunction contained "\<modify-labels-then-hide\>"
+syntax match muttrcFunction contained "\<modify-labels\>"
+syntax match muttrcFunction contained "\<modify-tags-then-hide\>"
+syntax match muttrcFunction contained "\<modify-tags\>"
 syntax match muttrcFunction contained "\<new-mime\>"
 syntax match muttrcFunction contained "\<next-entry\>"
 syntax match muttrcFunction contained "\<next-line\>"
-syntax match muttrcFunction contained "\<next-new\>"
 syntax match muttrcFunction contained "\<next-new-then-unread\>"
+syntax match muttrcFunction contained "\<next-new\>"
 syntax match muttrcFunction contained "\<next-page\>"
 syntax match muttrcFunction contained "\<next-subthread\>"
 syntax match muttrcFunction contained "\<next-thread\>"
 syntax match muttrcFunction contained "\<next-undeleted\>"
-syntax match muttrcFunction contained "\<next-unread\>"
 syntax match muttrcFunction contained "\<next-unread-mailbox\>"
+syntax match muttrcFunction contained "\<next-unread\>"
+syntax match muttrcFunction contained "\<noop\>"
 syntax match muttrcFunction contained "\<parent-message\>"
 syntax match muttrcFunction contained "\<pgp-menu\>"
 syntax match muttrcFunction contained "\<pipe-entry\>"
@@ -770,8 +784,8 @@
 syntax match muttrcFunction contained "\<postpone-message\>"
 syntax match muttrcFunction contained "\<previous-entry\>"
 syntax match muttrcFunction contained "\<previous-line\>"
-syntax match muttrcFunction contained "\<previous-new\>"
 syntax match muttrcFunction contained "\<previous-new-then-unread\>"
+syntax match muttrcFunction contained "\<previous-new\>"
 syntax match muttrcFunction contained "\<previous-page\>"
 syntax match muttrcFunction contained "\<previous-subthread\>"
 syntax match muttrcFunction contained "\<previous-thread\>"
@@ -782,8 +796,8 @@
 syntax match muttrcFunction contained "\<purge-message\>"
 syntax match muttrcFunction contained "\<purge-thread\>"
 syntax match muttrcFunction contained "\<quasi-delete\>"
-syntax match muttrcFunction contained "\<query\>"
 syntax match muttrcFunction contained "\<query-append\>"
+syntax match muttrcFunction contained "\<query\>"
 syntax match muttrcFunction contained "\<quit\>"
 syntax match muttrcFunction contained "\<quote-char\>"
 syntax match muttrcFunction contained "\<read-subthread\>"
@@ -801,40 +815,41 @@
 syntax match muttrcFunction contained "\<root-message\>"
 syntax match muttrcFunction contained "\<save-entry\>"
 syntax match muttrcFunction contained "\<save-message\>"
-syntax match muttrcFunction contained "\<search\>"
 syntax match muttrcFunction contained "\<search-next\>"
 syntax match muttrcFunction contained "\<search-opposite\>"
 syntax match muttrcFunction contained "\<search-reverse\>"
 syntax match muttrcFunction contained "\<search-toggle\>"
+syntax match muttrcFunction contained "\<search\>"
 syntax match muttrcFunction contained "\<select-entry\>"
 syntax match muttrcFunction contained "\<select-new\>"
 syntax match muttrcFunction contained "\<send-message\>"
 syntax match muttrcFunction contained "\<set-flag\>"
 syntax match muttrcFunction contained "\<shell-escape\>"
 syntax match muttrcFunction contained "\<show-limit\>"
+syntax match muttrcFunction contained "\<show-log-messages\>"
 syntax match muttrcFunction contained "\<show-version\>"
-syntax match muttrcFunction contained "\<sidebar-next\>"
 syntax match muttrcFunction contained "\<sidebar-next-new\>"
+syntax match muttrcFunction contained "\<sidebar-next\>"
 syntax match muttrcFunction contained "\<sidebar-open\>"
 syntax match muttrcFunction contained "\<sidebar-page-down\>"
 syntax match muttrcFunction contained "\<sidebar-page-up\>"
-syntax match muttrcFunction contained "\<sidebar-prev\>"
 syntax match muttrcFunction contained "\<sidebar-prev-new\>"
+syntax match muttrcFunction contained "\<sidebar-prev\>"
 syntax match muttrcFunction contained "\<sidebar-toggle-virtual\>"
 syntax match muttrcFunction contained "\<sidebar-toggle-visible\>"
 syntax match muttrcFunction contained "\<skip-quoted\>"
 syntax match muttrcFunction contained "\<smime-menu\>"
-syntax match muttrcFunction contained "\<sort\>"
 syntax match muttrcFunction contained "\<sort-mailbox\>"
 syntax match muttrcFunction contained "\<sort-reverse\>"
-syntax match muttrcFunction contained "\<subscribe\>"
+syntax match muttrcFunction contained "\<sort\>"
 syntax match muttrcFunction contained "\<subscribe-pattern\>"
+syntax match muttrcFunction contained "\<subscribe\>"
 syntax match muttrcFunction contained "\<sync-mailbox\>"
 syntax match muttrcFunction contained "\<tag-entry\>"
 syntax match muttrcFunction contained "\<tag-message\>"
 syntax match muttrcFunction contained "\<tag-pattern\>"
-syntax match muttrcFunction contained "\<tag-prefix\>"
 syntax match muttrcFunction contained "\<tag-prefix-cond\>"
+syntax match muttrcFunction contained "\<tag-prefix\>"
 syntax match muttrcFunction contained "\<tag-subthread\>"
 syntax match muttrcFunction contained "\<tag-thread\>"
 syntax match muttrcFunction contained "\<toggle-disposition\>"
@@ -846,8 +861,8 @@
 syntax match muttrcFunction contained "\<toggle-subscribed\>"
 syntax match muttrcFunction contained "\<toggle-unlink\>"
 syntax match muttrcFunction contained "\<toggle-write\>"
-syntax match muttrcFunction contained "\<top\>"
 syntax match muttrcFunction contained "\<top-page\>"
+syntax match muttrcFunction contained "\<top\>"
 syntax match muttrcFunction contained "\<transpose-chars\>"
 syntax match muttrcFunction contained "\<uncatchup\>"
 syntax match muttrcFunction contained "\<undelete-entry\>"
@@ -855,8 +870,8 @@
 syntax match muttrcFunction contained "\<undelete-pattern\>"
 syntax match muttrcFunction contained "\<undelete-subthread\>"
 syntax match muttrcFunction contained "\<undelete-thread\>"
-syntax match muttrcFunction contained "\<unsubscribe\>"
 syntax match muttrcFunction contained "\<unsubscribe-pattern\>"
+syntax match muttrcFunction contained "\<unsubscribe\>"
 syntax match muttrcFunction contained "\<untag-pattern\>"
 syntax match muttrcFunction contained "\<upcase-word\>"
 syntax match muttrcFunction contained "\<update-encoding\>"
@@ -864,11 +879,12 @@
 syntax match muttrcFunction contained "\<vfolder-from-query\>"
 syntax match muttrcFunction contained "\<vfolder-window-backward\>"
 syntax match muttrcFunction contained "\<vfolder-window-forward\>"
-syntax match muttrcFunction contained "\<view-attach\>"
 syntax match muttrcFunction contained "\<view-attachments\>"
+syntax match muttrcFunction contained "\<view-attach\>"
 syntax match muttrcFunction contained "\<view-file\>"
 syntax match muttrcFunction contained "\<view-mailcap\>"
 syntax match muttrcFunction contained "\<view-name\>"
+syntax match muttrcFunction contained "\<view-raw-message\>"
 syntax match muttrcFunction contained "\<view-text\>"
 syntax match muttrcFunction contained "\<what-key\>"
 syntax match muttrcFunction contained "\<write-fcc\>"
@@ -1029,4 +1045,5 @@
 
 let &cpo = s:cpo_save
 unlet s:cpo_save
-"EOF	vim: ts=8 noet tw=100 sw=8 sts=0 ft=vim
+
+" vim: ts=8 noet tw=100 sw=8 sts=0 ft=vim isk+=-
diff --git a/runtime/tutor/tutor.vim b/runtime/tutor/tutor.vim
index 6af69d0..f8a5496 100644
--- a/runtime/tutor/tutor.vim
+++ b/runtime/tutor/tutor.vim
@@ -1,12 +1,12 @@
 " Vim tutor support file
 " Author: Eduardo F. Amatria <eferna1@platea.pntic.mec.es>
 " Maintainer: Bram Moolenaar
-" Last Change:	2016 Jul 16
+" Last Change:	2018 Apr 11
 
 " This Vim script is used for detecting if a translation of the
 " tutor file exist, i.e., a tutor.xx file, where xx is the language.
 " If the translation does not exist, or no extension is given,
-" it defaults to the english version.
+" it defaults to the English version.
 
 " It is invoked by the vimtutor shell script.
 
diff --git a/src/po/Make_cyg.mak b/src/po/Make_cyg.mak
index fe49a34..4ee21a1 100644
--- a/src/po/Make_cyg.mak
+++ b/src/po/Make_cyg.mak
@@ -41,6 +41,7 @@
 		ru.cp1251 \
 		sk \
 		sk.cp1250 \
+		sr \
 		sv \
 		uk \
 		uk.cp1251 \
@@ -80,6 +81,7 @@
 		ru.mo \
 		sk.cp1250.mo \
 		sk.mo \
+		sr.mo \
 		sv.mo \
 		uk.cp1251.mo \
 		uk.mo \
diff --git a/src/po/Make_ming.mak b/src/po/Make_ming.mak
index 5dd2f2b..6973ad7 100644
--- a/src/po/Make_ming.mak
+++ b/src/po/Make_ming.mak
@@ -47,6 +47,7 @@
 		ru.cp1251 \
 		sk \
 		sk.cp1250 \
+		sr \
 		sv \
 		uk \
 		uk.cp1251 \
@@ -86,6 +87,7 @@
 		ru.mo \
 		sk.cp1250.mo \
 		sk.mo \
+		sr.mo \
 		sv.mo \
 		uk.cp1251.mo \
 		uk.mo \
diff --git a/src/po/Make_mvc.mak b/src/po/Make_mvc.mak
index 23a6e73..0f0adeb 100644
--- a/src/po/Make_mvc.mak
+++ b/src/po/Make_mvc.mak
@@ -39,6 +39,7 @@
 		ru.cp1251 \
 		sk \
 		sk.cp1250 \
+		sr \
 		sv \
 		uk \
 		uk.cp1251 \
@@ -78,6 +79,7 @@
 		ru.mo \
 		sk.cp1250.mo \
 		sk.mo \
+		sr.mo \
 		sv.mo \
 		uk.cp1251.mo \
 		uk.mo \
diff --git a/src/po/sr.po b/src/po/sr.po
index c1781e4..0f6d1c3 100644
--- a/src/po/sr.po
+++ b/src/po/sr.po
@@ -1217,7 +1217,7 @@
 msgstr "наставља се у %s"
 
 msgid "modeline"
-msgstr "режимска лнија (modeline)"
+msgstr "режимска линија (modeline)"
 
 msgid "--cmd argument"
 msgstr "--cmd аргумент"
@@ -4942,7 +4942,7 @@
 
 #, c-format
 msgid "Warning: Cannot find word list \"%s.%s.spl\" or \"%s.ascii.spl\""
-msgstr "Упозорење: Лста речи \"%s.%s.spl\" или \"%s.ascii.spl\" не може да се пронађе"
+msgstr "Упозорење: Листа речи \"%s.%s.spl\" или \"%s.ascii.spl\" не може да се пронађе"
 
 msgid "E797: SpellFileMissing autocommand deleted buffer"
 msgstr "E797: SpellFileMissing аутокоманда је обрисала бафер"
