diff --git a/runtime/syntax/debchangelog.vim b/runtime/syntax/debchangelog.vim
index 9d6dfe9..2d61206 100644
--- a/runtime/syntax/debchangelog.vim
+++ b/runtime/syntax/debchangelog.vim
@@ -3,7 +3,7 @@
 " Maintainer:  Debian Vim Maintainers
 " Former Maintainers: Gerfried Fuchs <alfie@ist.org>
 "                     Wichert Akkerman <wakkerma@debian.org>
-" Last Change: 2019 Apr 21
+" Last Change: 2019 Sep 07
 " URL: https://salsa.debian.org/vim-team/vim-debian/blob/master/syntax/debchangelog.vim
 
 " Standard syntax initialization
@@ -21,7 +21,7 @@
 syn match debchangelogName	contained "^[[:alnum:]][[:alnum:].+-]\+ "
 exe 'syn match debchangelogFirstKV	contained "; \('.s:urgency.'\|'.s:binNMU.'\)"'
 exe 'syn match debchangelogOtherKV	contained ", \('.s:urgency.'\|'.s:binNMU.'\)"'
-syn match debchangelogTarget	contained "\v %(frozen|unstable|sid|%(testing|%(old)=stable)%(-proposed-updates|-security)=|experimental|%(squeeze|wheezy|jessie)-%(backports%(-sloppy)=|lts|security)|stretch%(-backports%(-sloppy)=|-security)=|buster%(-backports|-security)=|bullseye|%(devel|precise|trusty|vivid|wily|xenial|yakkety|zesty|artful|bionic|cosmic|disco|eoan)%(-%(security|proposed|updates|backports|commercial|partner))=)+"
+syn match debchangelogTarget	contained "\v %(frozen|unstable|sid|%(testing|%(old)=stable)%(-proposed-updates|-security)=|experimental|%(squeeze|wheezy|jessie)-%(backports%(-sloppy)=|lts|security)|stretch%(-backports%(-sloppy)=|-security)=|buster%(-backports|-security)=|bullseye|bookworm|%(devel|precise|trusty|vivid|wily|xenial|yakkety|zesty|artful|bionic|cosmic|disco|eoan)%(-%(security|proposed|updates|backports|commercial|partner))=)+"
 syn match debchangelogVersion	contained "(.\{-})"
 syn match debchangelogCloses	contained "closes:\_s*\(bug\)\=#\=\_s\=\d\+\(,\_s*\(bug\)\=#\=\_s\=\d\+\)*"
 syn match debchangelogLP	contained "\clp:\s\+#\d\+\(,\s*#\d\+\)*"
diff --git a/runtime/syntax/debcopyright.vim b/runtime/syntax/debcopyright.vim
index c85ca37..c87b876 100644
--- a/runtime/syntax/debcopyright.vim
+++ b/runtime/syntax/debcopyright.vim
@@ -1,7 +1,7 @@
 " Vim syntax file
 " Language:    Debian copyright file
 " Maintainer:  Debian Vim Maintainers
-" Last Change: 2018 Feb 05
+" Last Change: 2019 Sep 07
 " URL: https://salsa.debian.org/vim-team/vim-debian/blob/master/syntax/debcopyright.vim
 
 " Standard syntax initialization
@@ -15,7 +15,7 @@
 syn case match
 
 syn match debcopyrightUrl       "\vhttps?://[[:alnum:]][-[:alnum:]]*[[:alnum:]]?(\.[[:alnum:]][-[:alnum:]]*[[:alnum:]]?)*\.[[:alpha:]][-[:alnum:]]*[[:alpha:]]?(:\d+)?(/[^[:space:]]*)?$"
-syn match debcopyrightKey       "^\%(Format\|Upstream-Name\|Upstream-Contact\|Disclaimer\|Source\|Comment\|Files\|Copyright\|License\): *"
+syn match debcopyrightKey       "^\%(Format\|Upstream-Name\|Upstream-Contact\|Disclaimer\|Source\|Comment\|Files\|Copyright\|License\|Files-Excluded\%(-[-a-zA-Z0-9]\+\)\=\): *"
 syn match debcopyrightEmail     "[_=[:alnum:]\.+-]\+@[[:alnum:]\./\-]\+"
 syn match debcopyrightEmail     "<.\{-}>"
 syn match debcopyrightComment   "^#.*$" contains=@Spell
diff --git a/runtime/syntax/debsources.vim b/runtime/syntax/debsources.vim
index f90476f..97acbf6 100644
--- a/runtime/syntax/debsources.vim
+++ b/runtime/syntax/debsources.vim
@@ -2,7 +2,7 @@
 " Language:     Debian sources.list
 " Maintainer:   Debian Vim Maintainers
 " Former Maintainer: Matthijs Mohlmann <matthijs@cacholong.nl>
-" Last Change: 2019 Apr 21
+" Last Change: 2019 Sep 07
 " URL: https://salsa.debian.org/vim-team/vim-debian/blob/master/syntax/debsources.vim
 
 " Standard syntax initialization
@@ -26,7 +26,7 @@
       \ 'wheezy', 'jessie', 'stretch', 'buster', 'bullseye', 'bookworm',
       \ 'sid', 'rc-buggy',
       \
-      \ 'trusty', 'xenial', 'bionic', 'cosmic', 'disco', 'eoan', 'devel'
+      \ 'trusty', 'xenial', 'bionic', 'disco', 'eoan', 'devel'
       \ ]
 let s:unsupported = [
       \ 'buzz', 'rex', 'bo', 'hamm', 'slink', 'potato',
@@ -35,7 +35,7 @@
       \ 'warty', 'hoary', 'breezy', 'dapper', 'edgy', 'feisty',
       \ 'gutsy', 'hardy', 'intrepid', 'jaunty', 'karmic', 'lucid',
       \ 'maverick', 'natty', 'oneiric', 'precise', 'quantal', 'raring', 'saucy',
-      \ 'utopic', 'vivid', 'wily', 'yakkety', 'zesty', 'artful'
+      \ 'utopic', 'vivid', 'wily', 'yakkety', 'zesty', 'artful', 'cosmic'
       \ ]
 let &cpo=s:cpo
 
diff --git a/runtime/syntax/freebasic.vim b/runtime/syntax/freebasic.vim
index bce7f9e..68e838f 100644
--- a/runtime/syntax/freebasic.vim
+++ b/runtime/syntax/freebasic.vim
@@ -1,12 +1,13 @@
 " Vim syntax file
 " Language:    FreeBasic
-" Maintainer:  Mark Manning <markem@airmail.net>
-" Updated:     10/22/2006
+" Maintainer:  Mark Manning <markem@sim1.us>
+" Updated:     10/9/2019
+" Version:		7.0b
 "
 " Description:
 "
 "	Based originally on the work done by Allan Kelly <Allan.Kelly@ed.ac.uk>
-"	Updated by Mark Manning <markem@airmail.net>
+"	Updated by Mark Manning <markem@sim1.us>
 "	Applied FreeBasic support to the already excellent support
 "	for standard basic syntax (like QB).
 "
@@ -138,7 +139,7 @@
 "	types of identifiers like functions, basic commands and
 "	such. MEM 9/9/2006
 "
-syn match	freebasicIdentifier		"\<[a-zA-Z_][a-zA-Z0-9_]*\>"
+syn match	freebasicIdentifier			"\<[a-zA-Z_][a-zA-Z0-9_]*\>"
 syn match	freebasicGenericFunction	"\<[a-zA-Z_][a-zA-Z0-9_]*\>\s*("me=e-1,he=e-1
 "
 "	Function list
@@ -154,9 +155,13 @@
 "
 "	Integer number, or floating point number without a dot and with "f".
 "
-syn region	freebasicHex		start="&h" end="\W"
-syn region	freebasicHexError	start="&h\x*[g-zG-Z]" end="\W"
-syn match	freebasicInteger	"\<\d\+\(u\=l\=\|lu\|f\)\>"
+syn region	freebasicHex			start="&h" end="\W"
+syn region	freebasicHexError		start="&h\x*[g-zG-Z]" end="\W"
+syn region	freebasicOctal			start="&o" end="\W"
+syn region	freebasicOctalError		start="&o[0-7]*[89a-zA-Z]" end="\W"
+syn region	freebasicBinary			start="&b" end="\W"
+syn region	freebasicBinaryError	start="&b[01]*[2-9a-zA-Z]" end="\W"
+syn match	freebasicInteger		"\<\d\+\(u\=l\=\|lu\|f\)\>"
 "
 "	Floating point number, with dot, optional exponent
 "
@@ -170,11 +175,11 @@
 "
 syn match	freebasicFloat		"\<\d\+e[-+]\=\d\+[fl]\=\>"
 "
-"	Hex number
+"	Octal number
 "
 syn case match
-syn match	freebasicOctal		"\<0\o*\>"
-syn match	freebasicOctalError	"\<0\o*[89]"
+syn match	freebasicOctal2			"\<0\o*\>"
+syn match	freebasicOctal2Error	"\<0\o*[89a-zA-Z]"
 "
 "	String and Character contstants
 "
@@ -183,7 +188,7 @@
 "
 "	Comments
 "
-syn match	freebasicSpecial	contained "\\."
+syn match	freebasicSpecial	contained "\\\\."
 syn region	freebasicComment	start="^rem" end="$" contains=freebasicSpecial,freebasicTodo
 syn region	freebasicComment	start=":\s*rem" end="$" contains=freebasicSpecial,freebasicTodo
 syn region	freebasicComment	start="\s*'" end="$" contains=freebasicSpecial,freebasicTodo
@@ -197,12 +202,12 @@
 "
 "	Create the clusters
 "
-syn cluster	freebasicNumber		contains=freebasicHex,freebasicOctal,freebasicInteger,freebasicFloat
-syn cluster	freebasicError		contains=freebasicHexError,freebasicOctalError
+syn cluster	freebasicNumber		contains=freebasicHex,freebasicOctal,freebasicOctal2,freebasicBinary,freebasicInteger,freebasicFloat
+syn cluster	freebasicError		contains=freebasicHexError,freebasicOctalError,freebasicOctal2,freebasicBinary
 "
 "	Used with OPEN statement
 "
-syn match	freebasicFilenumber	"#\d\+"
+syn match	freebasicFilenumber		"#\d\+"
 syn match	freebasicMathOperator	"[\+\-\=\|\*\/\>\<\%\()[\]]" contains=freebasicParen
 "
 "	The default methods for highlighting.  Can be overridden later
diff --git a/runtime/syntax/sshconfig.vim b/runtime/syntax/sshconfig.vim
index 755d08e..6c36f56 100644
--- a/runtime/syntax/sshconfig.vim
+++ b/runtime/syntax/sshconfig.vim
@@ -5,7 +5,8 @@
 " Contributor:  Leonard Ehrenfried <leonard.ehrenfried@web.de>
 " Contributor:  Karsten Hopp <karsten@redhat.com>
 " Contributor:  Dean, Adam Kenneth <adam.ken.dean@hpe.com>
-" Last Change:	2016 Dec 28
+" Last Change:	2019 Sep 09
+"		Added RemoteCommand from pull request #4809
 " SSH Version:	7.4p1
 "
 
@@ -206,6 +207,7 @@
 syn keyword sshconfigKeyword PubkeyAuthentication
 syn keyword sshconfigKeyword RSAAuthentication
 syn keyword sshconfigKeyword RekeyLimit
+syn keyword sshconfigKeyword RemoteCommand
 syn keyword sshconfigKeyword RemoteForward
 syn keyword sshconfigKeyword RequestTTY
 syn keyword sshconfigKeyword RhostsRSAAuthentication
diff --git a/runtime/syntax/vim.vim b/runtime/syntax/vim.vim
index 2ed4b30..78c9d26 100644
--- a/runtime/syntax/vim.vim
+++ b/runtime/syntax/vim.vim
@@ -28,6 +28,9 @@
 syn match   vimCommand contained	"\<z[-+^.=]\=\>"
 syn keyword vimStdPlugin contained	Arguments Break Cfilter Clear Continue DiffOrig Evaluate Finish Gdb Lfilter Man N[ext] Over P[rint] Program Run S Source Step Stop Termdebug TermdebugCommand TOhtml Winbar XMLent XMLns
 
+" added later
+syn keyword vimCommand contained	eval
+
 " vimOptions are caught only when contained in a vimSet {{{2
 syn keyword vimOption contained	acd ambw arshape background ballooneval bex bl brk buftype cf cinkeys cmdwinheight com conceallevel crb cscopeverbose cuc def diffexpr ea ei ep eventignore fdi fenc fileformat fkmap foldexpr foldopen fsync gfw guicursor guitabtooltip hidden hlg imactivatefunc imi inc inex isident keymap langnoremap linespace loadplugins ma matchtime mef mle modelineexpr mousehide mps nu opendevice paste pex pmbcs printdevice printoptions pw qe relativenumber rightleft rs runtimepath scr sect sft shellredir shiftwidth showmatch signcolumn smarttab sp spf srr startofline suffixes switchbuf ta tagfunc tbi term termwintype tgc titlelen toolbariconsize ttimeout ttymouse twt undofile varsofttabstop verbosefile viminfofile wak weirdinvert wig wildoptions winheight wm wrapscan
 syn keyword vimOption contained	ai anti autochdir backspace balloonevalterm bexpr bo browsedir casemap cfu cino cmp comments confirm cryptmethod cspc cul define diffopt ead ek equalalways ex fdl fencs fileformats flp foldignore foldtext ft ghr guifont helpfile highlight hls imactivatekey iminsert include inf isk keymodel langremap lisp lpl macatsui maxcombine menc mls modelines mousem msm number operatorfunc pastetoggle pexpr pmbfn printencoding prompt pythondll quoteescape remap rightleftcmd rtp sb scroll sections sh shellslash shm showmode siso smc spc spl ss statusline suffixesadd sws tabline taglength tbidi termbidi terse tgst titleold top ttimeoutlen ttyscroll tx undolevels vartabstop vfile virtualedit warn wfh wildchar wim winminheight wmh write
diff --git a/runtime/syntax/yaml.vim b/runtime/syntax/yaml.vim
index 626dc8a..49f7d04 100644
--- a/runtime/syntax/yaml.vim
+++ b/runtime/syntax/yaml.vim
@@ -3,6 +3,7 @@
 " Maintainer:       Nikolai Pavlov <zyx.vim@gmail.com>
 " First author:     Nikolai Weibull <now@bitwi.se>
 " Latest Revision:  2015-03-28
+" 		    removed duplicate yamlKeyValueDelimiter (pull #4799)
 
 if exists('b:current_syntax')
     finish
@@ -150,7 +151,6 @@
 syn match yamlBlockMappingMerge /<<\ze\s*:\%(\s\|$\)/ nextgroup=yamlKeyValueDelimiter contained
 
 syn match   yamlKeyValueDelimiter /\s*:/ contained
-syn match   yamlKeyValueDelimiter /\s*:/ contained
 
 syn cluster yamlScalarWithSpecials contains=yamlPlainScalar,yamlBlockMappingKey,yamlFlowMappingKey
 
