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
diff --git a/src/po/sr.po b/src/po/sr.po
index 0f6d1c3..1cf5f12 100644
--- a/src/po/sr.po
+++ b/src/po/sr.po
@@ -2,7 +2,6 @@
 #
 # Do ":help uganda"  in Vim to read copying and usage conditions.
 # Do ":help credits" in Vim to see a list of people who contributed.
-
 # Copyright (C) 2017
 # This file is distributed under the same license as the Vim package.
 # FIRST AUTHOR Ivan Pešić <ivan.pesic@gmail.com>, 2017.
@@ -10,14 +9,15 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: Vim(Serbian)\n"
-"Report-Msgid-Bugs-To: <ivan.pesic@gmail.com>\n"
-"POT-Creation-Date: 2017-12-21 08:34+0400\n"
-"PO-Revision-Date: 2017-12-27 10:29+0400\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2018-05-15 11:55+0400\n"
+"PO-Revision-Date: 2018-05-15 10:50+0400\n"
 "Last-Translator: Ivan Pešić <ivan.pesic@gmail.com>\n"
 "Language-Team: Serbian <LL@li.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
 
 msgid "E831: bf_key_init() called with empty password"
 msgstr "E831: bf_key_init() је позвана са празном лозинком"
@@ -102,7 +102,9 @@
 
 #, c-format
 msgid "E89: No write since last change for buffer %ld (add ! to override)"
-msgstr "E89: Од последње измене није било уписа за бафер %ld (додајте ! да премостите)"
+msgstr ""
+"E89: Од последње измене није било уписа за бафер %ld (додајте ! да "
+"премостите)"
 
 msgid "E948: Job still running (add ! to end the job)"
 msgstr "E948: Задатак се још извршава (додајте ! да зауставите задатак)"
@@ -117,7 +119,8 @@
 msgstr "E37: Није било уписа од последње промене"
 
 msgid "W14: Warning: List of file names overflow"
-msgstr "W14: Упозорење: Прекорачена је максимална величина листе имена датотека"
+msgstr ""
+"W14: Упозорење: Прекорачена је максимална величина листе имена датотека"
 
 #, c-format
 msgid "E92: Buffer %ld not found"
@@ -252,7 +255,8 @@
 msgstr "E917: Callback не може да се користи са %s()"
 
 msgid "E912: cannot use ch_evalexpr()/ch_sendexpr() with a raw or nl channel"
-msgstr "E912: ch_evalexpr()/ch_sendexpr() не може да се користи са raw или nl каналом"
+msgstr ""
+"E912: ch_evalexpr()/ch_sendexpr() не може да се користи са raw или nl каналом"
 
 msgid "E906: not an open channel"
 msgstr "E906: није отворен канал"
@@ -419,8 +423,8 @@
 msgid "'thesaurus' option is empty"
 msgstr "Опција 'thesaurus' је празна"
 
-#, c-format
-msgid "Scanning dictionary %s"
+#, c-format 
+msgid "Scanning dictionary: %s"
 msgstr "Скенирање речника: %s"
 
 msgid " (insert) Scroll (^E/^Y)"
@@ -531,21 +535,6 @@
 msgid "E109: Missing ':' after '?'"
 msgstr "E109: Недостаје ':' након '?'"
 
-msgid "E691: Can only compare List with List"
-msgstr "E691: List може да се пореди само са List"
-
-msgid "E692: Invalid operation for List"
-msgstr "E692: Неисправна операција за List"
-
-msgid "E735: Can only compare Dictionary with Dictionary"
-msgstr "E735: Dictionary може да се пореди само са Dictionary"
-
-msgid "E736: Invalid operation for Dictionary"
-msgstr "E736: Неисправна операција за Dictionary"
-
-msgid "E694: Invalid operation for Funcrefs"
-msgstr "E694: Неисправна операција за Funcrefs"
-
 msgid "E804: Cannot use '%' with Float"
 msgstr "E804: '%' не може да се користи са Float"
 
@@ -575,7 +564,8 @@
 msgstr "E115: Недостаје наводник: %s"
 
 msgid "Not enough memory to set references, garbage collection aborted!"
-msgstr "Нема довољно меморије за постављање референци, прекинуто је скупљање отпада"
+msgstr ""
+"Нема довољно меморије за постављање референци, прекинуто је скупљање отпада"
 
 msgid "E724: variable nested too deep for displaying"
 msgstr "E724: променљива је угњеждена предубоко да би се приказала"
@@ -671,6 +661,21 @@
 "\n"
 "\tПоследњи сет од "
 
+msgid "E691: Can only compare List with List"
+msgstr "E691: List може да се пореди само са List"
+
+msgid "E692: Invalid operation for List"
+msgstr "E692: Неисправна операција за List"
+
+msgid "E735: Can only compare Dictionary with Dictionary"
+msgstr "E735: Dictionary може да се пореди само са Dictionary"
+
+msgid "E736: Invalid operation for Dictionary"
+msgstr "E736: Неисправна операција за Dictionary"
+
+msgid "E694: Invalid operation for Funcrefs"
+msgstr "E694: Неисправна операција за Funcrefs"
+
 msgid "map() argument"
 msgstr "map() аргумент"
 
@@ -696,6 +701,12 @@
 msgid "&Ok"
 msgstr "&Ок"
 
+#, c-format 
+msgid "+-%s%3ld line: "
+msgid_plural "+-%s%3ld lines: "
+msgstr[0] "+-%s%3ld линија: "
+msgstr[1] "+-%s%3ld линија: "
+
 #, c-format
 msgid "E700: Unknown function: %s"
 msgstr "E700: Непозната функција: %s"
@@ -798,10 +809,22 @@
 msgid "E921: Invalid callback argument"
 msgstr "E921: Неисправан callback аргумент"
 
+#, c-format 
+msgid "<%s>%s%s  %d,  Hex %02x,  Oct %03o, Digr %s"
+msgstr "<%s>%s%s  %d,  Хекс %02x,  Окт %03o, Дигр %s"
+
 #, c-format
 msgid "<%s>%s%s  %d,  Hex %02x,  Octal %03o"
 msgstr "<%s>%s%s  %d,  Хекс %02x,  Октално %03o"
 
+#, c-format 
+msgid "> %d, Hex %04x, Oct %o, Digr %s"
+msgstr "> %d, Хекс %04x, Окт %o, Дигр %s"
+
+#, c-format 
+msgid "> %d, Hex %08x, Oct %o, Digr %s"
+msgstr "> %d, Хекс %08x, Окт %o, Дигр %s"
+
 #, c-format
 msgid "> %d, Hex %04x, Octal %o"
 msgstr "> %d, Хекс %04x, Октално %o"
@@ -1105,6 +1128,14 @@
 msgstr "Улазак у Debug режим.  Откуцајте \"cont\" за наставак."
 
 #, c-format
+msgid "Oldval = \"%s\""
+msgstr "Старавред = \"%s\""
+
+#, c-format
+msgid "Newval = \"%s\""
+msgstr "Новаавред = \"%s\""
+
+#, c-format
 msgid "line %ld: %s"
 msgstr "линија %ld: %s"
 
@@ -1134,6 +1165,10 @@
 msgid "%3d  %s %s  line %ld"
 msgstr "%3d  %s %s  линија %ld"
 
+#, c-format
+msgid "%3d  expr %s"
+msgstr "%3d  израз %s"
+
 msgid "E750: First use \":profile start {fname}\""
 msgstr "E750: Најпре користите \":profile start {fname}\""
 
@@ -1179,11 +1214,13 @@
 
 #, c-format
 msgid "W20: Required python version 2.x not supported, ignoring file: %s"
-msgstr "W20: Захтевани python version 2.x није подржан, датотека: %s се игнорише"
+msgstr ""
+"W20: Захтевани python version 2.x није подржан, датотека: %s се игнорише"
 
 #, c-format
 msgid "W21: Required python version 3.x not supported, ignoring file: %s"
-msgstr "W21: Захтевани python version 3.x није подржан, датотека: %s се игнорише"
+msgstr ""
+"W21: Захтевани python version 3.x није подржан, датотека: %s се игнорише"
 
 msgid "Source Vim script"
 msgstr "Изворна Vim скрипта"
@@ -1249,7 +1286,8 @@
 msgstr "E197: Језик не може да се постави на \"%s\""
 
 msgid "Entering Ex mode.  Type \"visual\" to go to Normal mode."
-msgstr "Улазак у Ex режим.  Откуцајте \"visual\" да бисте прешли у Нормални режим."
+msgstr ""
+"Улазак у Ex режим.  Откуцајте \"visual\" да бисте прешли у Нормални режим."
 
 msgid "E501: At end-of-file"
 msgstr "E501: На крају-датотеке"
@@ -1344,7 +1382,8 @@
 msgstr "E183: Кориснички дефинисане команде морају да почну великим словом"
 
 msgid "E841: Reserved name, cannot be used for user defined command"
-msgstr "E841: Резервисано име, не може да се користи за кориснички дефинисану команду"
+msgstr ""
+"E841: Резервисано име, не може да се користи за кориснички дефинисану команду"
 
 #, c-format
 msgid "E184: No such user-defined command: %s"
@@ -1394,7 +1433,9 @@
 msgstr "Додавање на крај Датотеке"
 
 msgid "E747: Cannot change directory, buffer is modified (add ! to override)"
-msgstr "E747: Директоријум не може да се промени, бафер је измењен (додајте ! за премошћавање)"
+msgstr ""
+"E747: Директоријум не може да се промени, бафер је измењен (додајте ! за "
+"премошћавање)"
 
 msgid "E186: No previous directory"
 msgstr "E186: Нема претгодног директоријума"
@@ -1693,7 +1734,7 @@
 msgid "[NOT converted]"
 msgstr "[НИЈЕ конвертовано]"
 
-msgid "[convered]"
+msgid "[converted]"
 msgstr "[конвертовано]"
 
 #, c-format
@@ -1720,7 +1761,9 @@
 msgstr "E676: Нема одговарајућих аутокоманди за acwrite бафер"
 
 msgid "E203: Autocommands deleted or unloaded buffer to be written"
-msgstr "E203: Аутокоманде су обрисале или уклониле из меморије бафер који требало да буде уписан"
+msgstr ""
+"E203: Аутокоманде су обрисале или уклониле из меморије бафер који требало да "
+"буде уписан"
 
 msgid "E204: Autocommand changed number of lines in unexpected way"
 msgstr "E204: Аутокоманде су на неочекиван начин промениле број линија"
@@ -1741,19 +1784,24 @@
 msgstr "је само за читање (додајте ! за премошћавање)"
 
 msgid "E506: Can't write to backup file (add ! to override)"
-msgstr "E506: Не може да се упише у резервну датотеку (додајте ! за премошћавање)"
+msgstr ""
+"E506: Не може да се упише у резервну датотеку (додајте ! за премошћавање)"
 
 msgid "E507: Close error for backup file (add ! to override)"
-msgstr "E507: Грешка код затварања за резервну датотеку (додајте ! за премошћавање)"
+msgstr ""
+"E507: Грешка код затварања за резервну датотеку (додајте ! за премошћавање)"
 
 msgid "E508: Can't read file for backup (add ! to override)"
-msgstr "E508: Резервна датотека не може да се прочита (додајте ! за премошћавање)"
+msgstr ""
+"E508: Резервна датотека не може да се прочита (додајте ! за премошћавање)"
 
 msgid "E509: Cannot create backup file (add ! to override)"
-msgstr "E509: Резервна датотека не може да се креира (додајте ! за премошћавање)"
+msgstr ""
+"E509: Резервна датотека не може да се креира (додајте ! за премошћавање)"
 
 msgid "E510: Can't make backup file (add ! to override)"
-msgstr "E510: Резервна датотека не може да се направи (додајте ! за премошћавање)"
+msgstr ""
+"E510: Резервна датотека не може да се направи (додајте ! за премошћавање)"
 
 msgid "E214: Can't find temp file for writing"
 msgstr "E214: Привремена датотека за упис не може да се пронађе"
@@ -1774,15 +1822,17 @@
 msgstr "E512: Затварање није успело"
 
 msgid "E513: write error, conversion failed (make 'fenc' empty to override)"
-msgstr "E513: грешка при упису, конверзија није успела (оставите 'fenc' празно да премостите)"
+msgstr ""
+"E513: грешка при упису, конверзија није успела (оставите 'fenc' празно да "
+"премостите)"
 
 #, c-format
 msgid ""
 "E513: write error, conversion failed in line %ld (make 'fenc' empty to "
 "override)"
 msgstr ""
-"E513: грешка при упису, конверзија није успела у линији %ld (оставите 'fenc' празно "
-"да премостите)"
+"E513: грешка при упису, конверзија није успела у линији %ld (оставите 'fenc' "
+"празно да премостите)"
 
 msgid "E514: write error (file system full?)"
 msgstr "E514: грешка при упису (систем датотека је пун?)"
@@ -1907,14 +1957,16 @@
 
 #, c-format
 msgid "W11: Warning: File \"%s\" has changed since editing started"
-msgstr "W11: Упозорење: Датотека \"%s\" је измењена откад је започето уређивање"
+msgstr ""
+"W11: Упозорење: Датотека \"%s\" је измењена откад је започето уређивање"
 
 msgid "See \":help W11\" for more info."
 msgstr "Погледајте \":help W11\" за више информација."
 
 #, c-format
 msgid "W16: Warning: Mode of file \"%s\" has changed since editing started"
-msgstr "W16: Упозорење: Режим датотеке \"%s\" је измењен откад је започето уређивање"
+msgstr ""
+"W16: Упозорење: Режим датотеке \"%s\" је измењен откад је започето уређивање"
 
 msgid "See \":help W16\" for more info."
 msgstr "Погледајте \":help W16\" за више информација."
@@ -2017,6 +2069,12 @@
 msgid "E351: Cannot delete fold with current 'foldmethod'"
 msgstr "E351: Склапање не може да се обрише са текћим 'foldmethod'"
 
+#, c-format
+msgid "+--%3ld line folded "
+msgid_plural "+--%3ld lines folded "
+msgstr[0] "+--%3ld линија подвијена"
+msgstr[1] "+--%3ld линија подвијено"
+
 msgid "E222: Add to read buffer"
 msgstr "E222: Додавање у бафер читања"
 
@@ -2106,7 +2164,8 @@
 msgstr "Vim дијалог"
 
 msgid "E232: Cannot create BalloonEval with both message and callback"
-msgstr "E232: Не може да се креира BalloonEval и са поруком и са повратним позивом"
+msgstr ""
+"E232: Не може да се креира BalloonEval и са поруком и са повратним позивом"
 
 msgid "_Cancel"
 msgstr "_Откажи"
@@ -2255,7 +2314,8 @@
 msgstr "E672: Није могуће отварање прозора унутар MDI апликације"
 
 msgid "Vim E458: Cannot allocate colormap entry, some colors may be incorrect"
-msgstr "Vim E458: colormap унос не може да се алоцира, неке боје су можда неисправне"
+msgstr ""
+"Vim E458: colormap унос не може да се алоцира, неке боје су можда неисправне"
 
 #, c-format
 msgid "E250: Fonts for the following charsets are missing in fontset %s:"
@@ -2400,7 +2460,8 @@
 msgstr "E456: PostScript resource датотека \"prolog.ps\" не може да се пронађе"
 
 msgid "E456: Can't find PostScript resource file \"cidfont.ps\""
-msgstr "E456: PostScript resource датотека \"cidfont.ps\" не може да се пронађе"
+msgstr ""
+"E456: PostScript resource датотека \"cidfont.ps\" не може да се пронађе"
 
 #, c-format
 msgid "E456: Can't find PostScript resource file \"%s.ps\""
@@ -2592,8 +2653,8 @@
 "E815: Sorry, this command is disabled, the MzScheme libraries could not be "
 "loaded."
 msgstr ""
-"E815: Жао нам је, ова команда је онемогућена, MzScheme библиотеке нису могле да "
-"се учитају."
+"E815: Жао нам је, ова команда је онемогућена, MzScheme библиотеке нису могле "
+"да се учитају."
 
 msgid ""
 "E895: Sorry, this command is disabled, the MzScheme's racket/base module "
@@ -2653,6 +2714,18 @@
 msgid "not allowed in the Vim sandbox"
 msgstr "није дозвољено у Vim sandbox-у"
 
+#, c-format
+msgid "E370: Could not load library %s"
+msgstr "E370: Библиотека %s није могла да се учита"
+
+msgid "Sorry, this command is disabled: the Perl library could not be loaded."
+msgstr ""
+"Жао нам је, ова команда је онемогућена: Perl библиотека није могла да "
+"се учита."
+
+msgid "E299: Perl evaluation forbidden in sandbox without the Safe module"
+msgstr "E299: Perl одређивање вредности у sandbox-у је забрањено без Safe модула"
+
 msgid "E836: This Vim cannot execute :python after using :py3"
 msgstr "E836: Овај Vim не може да изврши :python након коришћења :py3"
 
@@ -2660,15 +2733,15 @@
 "E263: Sorry, this command is disabled, the Python library could not be "
 "loaded."
 msgstr ""
-"E263: Жао нам је, ова команда је онемогућена, Python библиотека није "
-"могла да се учита."
+"E263: Жао нам је, ова команда је онемогућена, Python библиотека није могла "
+"да се учита."
 
 msgid ""
 "E887: Sorry, this command is disabled, the Python's site module could not be "
 "loaded."
 msgstr ""
-"E887: Жао нам је, ова команда је онемогућена, Python-ов site модул "
-"није могао да се учита."
+"E887: Жао нам је, ова команда је онемогућена, Python-ов site модул није "
+"могао да се учита."
 
 msgid "E659: Cannot invoke Python recursively"
 msgstr "E659: Python не може да се позива рекурзивно"
@@ -2682,7 +2755,8 @@
 msgid ""
 "E266: Sorry, this command is disabled, the Ruby library could not be loaded."
 msgstr ""
-"E266: Жао нам је, ова команда је онемогућена, Ruby библиотека није могла да се учита."
+"E266: Жао нам је, ова команда је онемогућена, Ruby библиотека није могла да "
+"се учита."
 
 msgid "E267: unexpected return"
 msgstr "E267: неочекиван return"
@@ -2749,22 +2823,26 @@
 msgid ""
 "cannot register callback command: buffer/window is already being deleted"
 msgstr ""
-"команда повратног позива не може да се региструје: бафер/прозор је већ обрисан"
+"команда повратног позива не може да се региструје: бафер/прозор је већ "
+"обрисан"
 
 msgid ""
 "E280: TCL FATAL ERROR: reflist corrupt!? Please report this to vim-dev@vim."
 "org"
 msgstr ""
-"E280: TCL ФАТАЛНА ГРЕШКА: reflist је оштећена!? Молимо пријавите ово на vim-dev@vim."
-"org"
+"E280: TCL ФАТАЛНА ГРЕШКА: reflist је оштећена!? Молимо пријавите ово на "
+"vim-dev@vim.org"
 
 msgid "cannot register callback command: buffer/window reference not found"
-msgstr "команда повратног позива не може да се региструје: референца бафера/прозора није пронађена"
+msgstr ""
+"команда повратног позива не може да се региструје: референца бафера/прозора "
+"није пронађена"
 
 msgid ""
 "E571: Sorry, this command is disabled: the Tcl library could not be loaded."
 msgstr ""
-"E571: Жао нам је, ова команда је онемогућена: Tcl библиотека није могла да се учита."
+"E571: Жао нам је, ова команда је онемогућена: Tcl библиотека није могла да "
+"се учита."
 
 #, c-format
 msgid "E572: exit code %d"
@@ -2842,7 +2920,8 @@
 msgstr "Vim: Грешка: Покретање gvim из NetBeans није успело\n"
 
 msgid "Vim: Error: This version of Vim does not run in a Cygwin terminal\n"
-msgstr "Vim: Грешка: Ова верзија Vim не може да се покрене из Cygwin терминала\n"
+msgstr ""
+"Vim: Грешка: Ова верзија Vim не може да се покрене из Cygwin терминала\n"
 
 msgid "Vim: Warning: Output is not to a terminal\n"
 msgstr "Vim: Упозорење: Излаз није у терминал\n"
@@ -2900,7 +2979,8 @@
 "Where case is ignored prepend / to make flag upper case"
 msgstr ""
 "\n"
-"Где се мала/велика слова игноришу ставите испред / како би претворили индикатор у велика слова"
+"Где се мала/велика слова игноришу ставите испред / како би претворили "
+"индикатор у велика слова"
 
 msgid ""
 "\n"
@@ -3038,19 +3118,25 @@
 msgstr "+<бројл>\t\tПочни на линији <бројл>"
 
 msgid "--cmd <command>\tExecute <command> before loading any vimrc file"
-msgstr "--cmd <команда>\tИзврши <команда> пре учитавања било које vimrc датотеке"
+msgstr ""
+"--cmd <команда>\tИзврши <команда> пре учитавања било које vimrc датотеке"
 
 msgid "-c <command>\t\tExecute <command> after loading the first file"
 msgstr "-c <команда>\t\tИзврши <команда> након учитавања прве датотеке"
 
 msgid "-S <session>\t\tSource file <session> after loading the first file"
-msgstr "-S <сесија>\t\tУчитај као извор датотеку <сесија> након учитавања прве датотеке"
+msgstr ""
+"-S <сесија>\t\tИзворна датотека <сесија> након учитавања прве "
+"датотеке"
 
 msgid "-s <scriptin>\tRead Normal mode commands from file <scriptin>"
-msgstr "-s <скриптулаз>\tЧитај команде Нормалног режима из датотеке <скриптулаз>"
+msgstr ""
+"-s <скриптулаз>\tЧитај команде Нормалног режима из датотеке <скриптулаз>"
 
 msgid "-w <scriptout>\tAppend all typed commands to file <scriptout>"
-msgstr "-w <скриптизлаз>\tНадовежи све откуцане команде на крај датотеке <скриптизлаз>"
+msgstr ""
+"-w <скриптизлаз>\tНадовежи све откуцане команде на крај датотеке "
+"<скриптизлаз>"
 
 msgid "-W <scriptout>\tWrite all typed commands to file <scriptout>"
 msgstr "-W <скриптизлаз>\tУписуј све откуцане команде у датотеку <скриптизлаз>"
@@ -3077,19 +3163,20 @@
 
 msgid ""
 "--remote-wait-silent <files>  Same, don't complain if there is no server"
-msgstr ""
-"--remote-wait-silent <датотеке>  Исто, не буни се ако нема сервера"
+msgstr "--remote-wait-silent <датотеке>  Исто, не буни се ако нема сервера"
 
 msgid ""
 "--remote-tab[-wait][-silent] <files>  As --remote but use tab page per file"
 msgstr ""
-"--remote-tab[-wait][-silent] <датотеке>  Као --remote али користи једну картицу по датотеци"
+"--remote-tab[-wait][-silent] <датотеке>  Као --remote али користи једну "
+"картицу по датотеци"
 
 msgid "--remote-send <keys>\tSend <keys> to a Vim server and exit"
 msgstr "--remote-send <тастери>\tПошаљи <тастери> Vim серверу и изађи"
 
 msgid "--remote-expr <expr>\tEvaluate <expr> in a Vim server and print result"
-msgstr "--remote-expr <израз>\tИзрачунај <израз> у Vim серверу и одштампај резултат"
+msgstr ""
+"--remote-expr <израз>\tИзрачунај <израз> у Vim серверу и одштампај резултат"
 
 msgid "--serverlist\t\tList available Vim server names and exit"
 msgstr "--serverlist\t\tИзлистај имена доступних Vim сервера и изађи"
@@ -3104,7 +3191,9 @@
 msgstr "-i <viminfo>\t\tКористи <viminfo> уместо .viminfo"
 
 msgid "--clean\t\t'nocompatible', Vim defaults, no plugins, no viminfo"
-msgstr "--clean\t\t'nocompatible', Vim подразумеване вредности, без додатака, без viminfo"
+msgstr ""
+"--clean\t\t'nocompatible', Vim подразумеване вредности, без додатака, без "
+"viminfo"
 
 msgid "-h  or  --help\tPrint Help (this message) and exit"
 msgstr "-h  or  --help\tИспиши Помоћ (ову поруку) и изађи"
@@ -3161,10 +3250,13 @@
 msgstr "-borderwidth <ширина>\tКористи оквир ширине <ширина> (такође: -bw)"
 
 msgid "-scrollbarwidth <width>  Use a scrollbar width of <width> (also: -sw)"
-msgstr "-scrollbarwidth <ширина>  Користи Линију за скроловање ширине <ширина> (такође: -sw)"
+msgstr ""
+"-scrollbarwidth <ширина>  Користи Линију за скроловање ширине <ширина> "
+"(такође: -sw)"
 
 msgid "-menuheight <height>\tUse a menu bar height of <height> (also: -mh)"
-msgstr "-menuheight <ширина>\tКористи линију менија висине <висина> (такође: -mh)"
+msgstr ""
+"-menuheight <ширина>\tКористи линију менија висине <висина> (такође: -mh)"
 
 msgid "-reverse\t\tUse reverse video (also: -rv)"
 msgstr "-reverse\t\tКористи обрнути видео (такође: -rv)"
@@ -3186,7 +3278,9 @@
 msgstr "-display <дисплеј>\tПокрени vim на <дисплеј> (такође: --display)"
 
 msgid "--role <role>\tSet a unique role to identify the main window"
-msgstr "--role <улога>\tПостави јединствену улогу да би се идентификовао главни прозор"
+msgstr ""
+"--role <улога>\tПостави јединствену улогу да би се идентификовао главни "
+"прозор"
 
 msgid "--socketid <xid>\tOpen Vim inside another GTK widget"
 msgstr "--socketid <xid>\tОтвори Vim унутар другог GTK виџета"
@@ -3284,7 +3378,8 @@
 msgstr "E286: Отварање методе уноса није успело"
 
 msgid "E287: Warning: Could not set destroy callback to IM"
-msgstr "E287: Упозорење: Постављање повратне функције за уништење IM није успело"
+msgstr ""
+"E287: Упозорење: Постављање повратне функције за уништење IM није успело"
 
 msgid "E288: input method doesn't support any style"
 msgstr "E288: метод уноса не подржава ниједан стил"
@@ -3330,7 +3425,8 @@
 
 #, c-format
 msgid "E303: Unable to open swap file for \"%s\", recovery impossible"
-msgstr "E303: Отварање swap датотеке за \"%s\" није успело, опоравак је немогућ"
+msgstr ""
+"E303: Отварање swap датотеке за \"%s\" није успело, опоравак је немогућ"
 
 msgid "E304: ml_upd_block0(): Didn't get block 0??"
 msgstr "E304: ml_upd_block0(): Блок бр 0 није добављен??"
@@ -3382,8 +3478,7 @@
 #, c-format
 msgid ""
 "E833: %s is encrypted and this version of Vim does not support encryption"
-msgstr ""
-"E833: %s је шифрована и ова верзија Vim-а не подржава шифровање"
+msgstr "E833: %s је шифрована и ова верзија Vim-а не подржава шифровање"
 
 msgid " has been damaged (page size is smaller than minimum value).\n"
 msgstr " је оштећена (величина странице је маља од минималне вредности).\n"
@@ -3422,7 +3517,8 @@
 "If you wrote the text file after changing the crypt key press enter"
 msgstr ""
 "\n"
-"Ако сте уписали текст датотеку на диск након промене кључа за шифрирање притисните ентер"
+"Ако сте уписали текст датотеку на диск након промене кључа за шифрирање "
+"притисните ентер"
 
 msgid ""
 "\n"
@@ -3469,7 +3565,8 @@
 msgid ""
 "E312: Errors detected while recovering; look for lines starting with ???"
 msgstr ""
-"E312: Откривене су грешке приликом опоравка; потражите линије које почињу са ???"
+"E312: Откривене су грешке приликом опоравка; потражите линије које почињу "
+"са ???"
 
 msgid "See \":help E312\" for more information."
 msgstr "Погледајте \":help E312\" за више информација."
@@ -3957,8 +4054,8 @@
 "E343: Invalid path: '**[number]' must be at the end of the path or be "
 "followed by '%s'."
 msgstr ""
-"E343: Неисправна путања: '**[број]' мора бити на крају путање или да "
-"иза њега следи '%s'."
+"E343: Неисправна путања: '**[број]' мора бити на крају путање или да иза "
+"њега следи '%s'."
 
 #, c-format
 msgid "E344: Can't find directory \"%s\" in cdpath"
@@ -4022,7 +4119,8 @@
 msgstr "E663: На крају листе промена"
 
 msgid "Type  :qa!  and press <Enter> to abandon all changes and exit Vim"
-msgstr "Откуцајте  :qa!  и притисните <Ентер> да одбаците све измене и напустите Vim"
+msgstr ""
+"Откуцајте  :qa!  и притисните <Ентер> да одбаците све измене и напустите Vim"
 
 #, c-format
 msgid "1 line %sed 1 time"
@@ -4149,8 +4247,8 @@
 "lld од %lld"
 
 #, c-format
-msgid "(+%ld for BOM)"
-msgstr "(+%ld за BOM)"
+msgid "(+%lld for BOM)"
+msgstr "(+%lld за BOM)"
 
 msgid "Thanks for flying Vim"
 msgstr "Хвала што летите са Vim"
@@ -4264,7 +4362,8 @@
 msgstr "E542: неуравнотежене групе"
 
 msgid "E946: Cannot make a terminal with running job modifiable"
-msgstr "E946: Терминал са задатком који се извршава не може да се учини измењивим"
+msgstr ""
+"E946: Терминал са задатком који се извршава не може да се учини измењивим"
 
 msgid "E590: A preview window already exists"
 msgstr "E590: Прозор за преглед већ постоји"
@@ -4272,6 +4371,9 @@
 msgid "W17: Arabic requires UTF-8, do ':set encoding=utf-8'"
 msgstr "W17: Арапски захтева UTF-8, извршите ':set encoding=utf-8'"
 
+msgid "E954: 24-bit colors are not supported on this environment"
+msgstr "E954: Ово окружење не подржава 24-битне боје"
+
 #, c-format
 msgid "E593: Need at least %d lines"
 msgstr "E593: Потребно је најмање %d линија"
@@ -4556,6 +4658,9 @@
 msgid "shell returned %d"
 msgstr "командно окружење је вратило %d"
 
+msgid "E926: Current location list was changed"
+msgstr "E926: Текућа листа локација је промењена"
+
 #, c-format
 msgid "E372: Too many %%%c in format string"
 msgstr "E372: Превише %%%c стрингу формата"
@@ -4594,9 +4699,6 @@
 msgid "E925: Current quickfix was changed"
 msgstr "E925: Текући quickfix је промењен"
 
-msgid "E926: Current location list was changed"
-msgstr "E926: Текућа листа локација је промењена"
-
 #, c-format
 msgid "(%d of %d)%s%s: "
 msgstr "(%d од %d)%s%s: "
@@ -4759,6 +4861,9 @@
 msgid "E867: (NFA) Unknown operator '\\z%c'"
 msgstr "E867: (NFA) Непознати оператор '\\z%c'"
 
+msgid "E951: \\% value too large"
+msgstr "E951: Вредност \\% је предугачка"
+
 #, c-format
 msgid "E867: (NFA) Unknown operator '\\%%%c'"
 msgstr "E867: (NFA) Непознати оператор '\\%%%c'"
@@ -4792,11 +4897,12 @@
 "E875: (NFA regexp) (While converting from postfix to NFA), too many states "
 "left on stack"
 msgstr ""
-"E875: (NFA regexp) (Док је вршена конверзија из postfix у NFA), превише стања "
-"је остало на стеку"
+"E875: (NFA regexp) (Док је вршена конверзија из postfix у NFA), превише "
+"стања је остало на стеку"
 
 msgid "E876: (NFA regexp) Not enough space to store the whole NFA "
-msgstr "E876: (NFA regexp) Нема довољно простора да се ускладишти комплетан NFA "
+msgstr ""
+"E876: (NFA regexp) Нема довољно простора да се ускладишти комплетан NFA "
 
 msgid "E878: (NFA) Could not allocate memory for branch traversal!"
 msgstr "E878: (NFA) Није могла да се алоцира меморија за обилазак грана!"
@@ -4804,7 +4910,8 @@
 msgid ""
 "Could not open temporary log file for writing, displaying on stderr ... "
 msgstr ""
-"Привремена лог датотека није могла да се отвори за упис, приказује се на stderr ... "
+"Привремена лог датотека није могла да се отвори за упис, приказује се на "
+"stderr ... "
 
 #, c-format
 msgid "(NFA) COULD NOT OPEN %s !"
@@ -4938,11 +5045,15 @@
 
 #, 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\" не може да се "
+"пронађе"
 
 #, 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 аутокоманда је обрисала бафер"
@@ -5091,7 +5202,9 @@
 
 #, c-format
 msgid "Different combining flag in continued affix block in %s line %d: %s"
-msgstr "Различит индикатор комбиновања у настављеном блоку наставака у %s линија %d: %s"
+msgstr ""
+"Различит индикатор комбиновања у настављеном блоку наставака у %s линија %d: "
+"%s"
 
 #, c-format
 msgid "Duplicate affix in %s line %d: %s"
@@ -5102,8 +5215,8 @@
 "Affix also used for BAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST in %s "
 "line %d: %s"
 msgstr ""
-"Наставак се такође користиBAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST "
-"у %s линија %d: %s"
+"Наставак се такође користи за BAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST у %s"
+"линија %d: %s"
 
 #, c-format
 msgid "Expected Y or N in %s line %d: %s"
@@ -5163,7 +5276,8 @@
 
 #, c-format
 msgid "%s value differs from what is used in another .aff file"
-msgstr "%s вредност се разликује од онога што је коришћено у другој .aff датотеци"
+msgstr ""
+"%s вредност се разликује од онога што је коришћено у другој .aff датотеци"
 
 #, c-format
 msgid "Reading dictionary file %s ..."
@@ -5174,8 +5288,8 @@
 msgstr "E760: Нема броја речи у %s"
 
 #, c-format
-msgid "line %6d, word %6d - %s"
-msgstr "линија %6d, реч %6d - %s"
+msgid "line %6d, word %6ld - %s"
+msgstr "линија %6d, реч %6ld - %s"
 
 #, c-format
 msgid "Duplicate word in %s line %d: %s"
@@ -5261,8 +5375,9 @@
 msgid "E751: Output file name must not have region name"
 msgstr "E751: Име излазне датотеке не сме да има име региона"
 
-msgid "E754: Only up to 8 regions supported"
-msgstr "E754: Подржано је само до 8 региона"
+#, c-format
+msgid "E754: Only up to %ld regions supported"
+msgstr "E754: Подржано је само до %ld региона"
 
 #, c-format
 msgid "E755: Invalid region in %s"
@@ -5647,6 +5762,10 @@
 msgid "Cannot open $VIMRUNTIME/rgb.txt"
 msgstr "Не може да се отвори $VIMRUNTIME/rgb.txt"
 
+#, c-format
+msgid "Kill job in \"%s\"?"
+msgstr "Да ли да се уништи задатак у \"%s\"?"
+
 msgid "Terminal"
 msgstr "Терминал"
 
@@ -5662,6 +5781,13 @@
 msgid "finished"
 msgstr "завршен"
 
+#, c-format
+msgid "E953: File exists: %s"
+msgstr "E953: Датотека већ постоји: %s"
+
+msgid "E955: Not a terminal buffer"
+msgstr "E955: Није терминалски бафер"
+
 msgid "new shell started\n"
 msgstr "покренуто ново командно окружење\n"
 
@@ -5686,11 +5812,13 @@
 msgstr "E825: Искварена датотека за опозив (%s): %s"
 
 msgid "Cannot write undo file in any directory in 'undodir'"
-msgstr "Датотека за опозив не може да се упише ни у један директоријум из 'undodir'"
+msgstr ""
+"Датотека за опозив не може да се упише ни у један директоријум из 'undodir'"
 
 #, c-format
 msgid "Will not overwrite with undo file, cannot read: %s"
-msgstr "Неће се вршити преписивање са датотеком опозива, читање није могуће: %s"
+msgstr ""
+"Неће се вршити преписивање са датотеком опозива, читање није могуће: %s"
 
 #, c-format
 msgid "Will not overwrite, this is not an undo file: %s"
@@ -5725,7 +5853,8 @@
 
 #, c-format
 msgid "E832: Non-encrypted file has encrypted undo file: %s"
-msgstr "E832: Датотека која није шифрована има шифровану датотеку за опозив: %s"
+msgstr ""
+"E832: Датотека која није шифрована има шифровану датотеку за опозив: %s"
 
 #, c-format
 msgid "E826: Undo file decryption failed: %s"
@@ -5740,7 +5869,8 @@
 msgstr "E824: Некомпатибилна датотека за опозив: %s"
 
 msgid "File contents changed, cannot use undo info"
-msgstr "Садржај датотеке је промењен, информације за опозив не могу да се користе"
+msgstr ""
+"Садржај датотеке је промењен, информације за опозив не могу да се користе"
 
 #, c-format
 msgid "Finished reading undo file %s"
@@ -6276,7 +6406,8 @@
 msgstr "Уређује селектовауе датотеку(е) са Vim-ом"
 
 msgid "Error creating process: Check if gvim is in your path!"
-msgstr "Грешка приликом креирања процеса: Проверите да ли је gvim у вашој путањи!"
+msgstr ""
+"Грешка приликом креирања процеса: Проверите да ли је gvim у вашој путањи!"
 
 msgid "gvimext.dll error"
 msgstr "gvimext.dll грешка"
@@ -6297,10 +6428,13 @@
 msgstr "E10: Иза \\ треба да је /, ? или &"
 
 msgid "E11: Invalid in command-line window; <CR> executes, CTRL-C quits"
-msgstr "E11: Неважеће у прозору командне линије; <CR> извршава, CTRL-C отказује"
+msgstr ""
+"E11: Неважеће у прозору командне линије; <CR> извршава, CTRL-C отказује"
 
 msgid "E12: Command not allowed from exrc/vimrc in current dir or tag search"
-msgstr "E12: Постији забрана за команду у exrc/vimrc у текућој претрази директоријума или ознаке"
+msgstr ""
+"E12: Постоји забрана за команду у exrc/vimrc у текућој претрази "
+"директоријума или ознаке"
 
 msgid "E171: Missing :endif"
 msgstr "E171: Недостаје :endif"
@@ -6359,6 +6493,14 @@
 msgstr "E475: Неважећи аргумент: %s"
 
 #, c-format
+msgid "E475: Invalid value for argument %s"
+msgstr "E475: Неважећa вредност за аргумент: %s"
+
+#, c-format
+msgid "E475: Invalid value for argument %s: %s"
+msgstr "E475: Неважећa вредност за аргумент %s: %s"
+
+#, c-format
 msgid "E15: Invalid expression: %s"
 msgstr "E15: Неважећи израз: %s"
 
@@ -6380,10 +6522,6 @@
 msgstr "E667: Fsync није успео"
 
 #, c-format
-msgid "E370: Could not load library %s"
-msgstr "E370: Библиотека %s није могла да се учита"
-
-#, c-format
 msgid "E448: Could not load library function %s"
 msgstr "E448: Библиотечка функција %s није могла да се учита"
 
@@ -6412,13 +6550,15 @@
 msgstr "E25: GUI не може да се користи: Није омогућен у време компилације"
 
 msgid "E26: Hebrew cannot be used: Not enabled at compile time\n"
-msgstr "E26: хебрејски не може да се користи: Није омогућен у време компилације\n"
+msgstr ""
+"E26: хебрејски не може да се користи: Није омогућен у време компилације\n"
 
 msgid "E27: Farsi cannot be used: Not enabled at compile time\n"
 msgstr "E27: фарси не може да се користи: Није омогућен у време компилације\n"
 
 msgid "E800: Arabic cannot be used: Not enabled at compile time\n"
-msgstr "E800: арапски не може да се користи: Није омогућен у време компилације\n"
+msgstr ""
+"E800: арапски не може да се користи: Није омогућен у време компилације\n"
 
 #, c-format
 msgid "E28: No such highlight group name: %s"
@@ -6624,7 +6764,8 @@
 msgstr "E463: Регион је чуван, измена није могућа"
 
 msgid "E744: NetBeans does not allow changes in read-only files"
-msgstr "E744: NetBeans не дозвољава измене датотека које смеју само да се читају"
+msgstr ""
+"E744: NetBeans не дозвољава измене датотека које смеју само да се читају"
 
 msgid "E363: pattern uses more memory than 'maxmempattern'"
 msgstr "E363: шаблон користи више меморије од 'maxmempattern'"
@@ -6653,6 +6794,9 @@
 msgid "E919: Directory not found in '%s': \"%s\""
 msgstr "E919: Није пронађен директоријум у '%s': \"%s\""
 
+msgid "E952: Autocommand caused recursive behavior"
+msgstr "E952: Аутокомандa je изазвала рекурзивно понашање"
+
 msgid "search hit TOP, continuing at BOTTOM"
 msgstr "претрага је достигла ВРХ, наставља се на ДНУ"
 
@@ -6692,11 +6836,14 @@
 msgid ""
 "expected int(), long() or something supporting coercing to long(), but got %s"
 msgstr ""
-"очекивало се int(), long() или нешто што подржава спајање са long(), али је добијено %s"
+"очекивало се int(), long() или нешто што подржава спајање са long(), али је "
+"добијено %s"
 
 #, c-format
 msgid "expected int() or something supporting coercing to int(), but got %s"
-msgstr "очекивало се int() или нешто што подржава спајање са int(), али је добијено %s"
+msgstr ""
+"очекивало се int() или нешто што подржава спајање са int(), али је добијено %"
+"s"
 
 msgid "value is too large to fit into C int type"
 msgstr "вредност је сувише велика да се смести у C int тип"
@@ -6729,7 +6876,9 @@
 
 #, c-format
 msgid "expected 3-tuple as imp.find_module() result, but got tuple of size %d"
-msgstr "Као резултат imp.find_module() очекује се триплет, али је добијена н-торка величине %d"
+msgstr ""
+"Као резултат imp.find_module() очекује се триплет, али је добијена н-торка "
+"величине %d"
 
 msgid "internal error: imp.find_module returned tuple with NULL"
 msgstr "интерна грешка: imp.find_module је вратио н-торку са NULL"
@@ -6749,7 +6898,9 @@
 
 #, c-format
 msgid "expected sequence element of size 2, but got sequence of size %d"
-msgstr "очекивао се елемент секвенце величине 2, алил је добијена секвенца величине %d"
+msgstr ""
+"очекивао се елемент секвенце величине 2, али је добијена секвенца "
+"величине %d"
 
 msgid "list constructor does not accept keyword arguments"
 msgstr "конструктор листе не прихвата кључне речи за аргументе"
@@ -6780,7 +6931,8 @@
 
 #, c-format
 msgid "attempt to assign sequence of size %d to extended slice of size %d"
-msgstr "покушај доделе секвенце величине %d како би се продужио slice величине %d"
+msgstr ""
+"покушај доделе секвенце величине %d како би се продужио slice величине %d"
 
 msgid "failed to add item to list"
 msgstr "ставка није могла да се дода листи"
@@ -6916,3 +7068,47 @@
 msgstr ""
 "Путања није могла да се постави: sys.path није у листи\n"
 "Сада би требало да додате vim.VIM_SPECIAL_PATH на крај sys.path"
+
+msgid ""
+"Vim macro files (*.vim)\t*.vim\n"
+"All Files (*.*)\t*.*\n"
+msgstr ""
+"Vim макро датотеке (*.vim)\t*.vim\n"
+"Све датотеке (*.*)\t*.*\n"
+
+msgid "All Files (*.*)\t*.*\n"
+msgstr "Све датотеке (*.*)\t*.*\n"
+
+msgid ""
+"All Files (*.*)\t*.*\n"
+"C source (*.c, *.h)\t*.c;*.h\n"
+"C++ source (*.cpp, *.hpp)\t*.cpp;*.hpp\n"
+"VB code (*.bas, *.frm)\t*.bas;*.frm\n"
+"Vim files (*.vim, _vimrc, _gvimrc)\t*.vim;_vimrc;_gvimrc\n"
+msgstr ""
+"Све датотеке (*.*)\t*.*\n"
+"C изворни код (*.c, *.h)\t*.c;*.h\n"
+"C++ изворни код (*.cpp, *.hpp)\t*.cpp;*.hpp\n"
+"VB код (*.bas, *.frm)\t*.bas;*.frm\n"
+"Vim датотеке (*.vim, _vimrc, _gvimrc)\t*.vim;_vimrc;_gvimrc\n"
+
+msgid ""
+"Vim macro files (*.vim)\t*.vim\n"
+"All Files (*)\t*\n"
+msgstr ""
+"Vim макро датотеке (*.vim)\t*.vim\n"
+"Све датотеке (*)\t*\n"
+
+msgid "All Files (*)\t*\n"
+msgstr "Све датотеке (*)\t*\n"
+
+msgid ""
+"All Files (*)\t*\n"
+"C source (*.c, *.h)\t*.c;*.h\n"
+"C++ source (*.cpp, *.hpp)\t*.cpp;*.hpp\n"
+"Vim files (*.vim, _vimrc, _gvimrc)\t*.vim;_vimrc;_gvimrc\n"
+msgstr ""
+"Све датотеке (*)\t*\n"
+"C изворни код (*.c, *.h)\t*.c;*.h\n"
+"C++ изворни код (*.cpp, *.hpp)\t*.cpp;*.hpp\n"
+"Vim датотеке (*.vim, _vimrc, _gvimrc)\t*.vim;_vimrc;_gvimrc\n"
