diff --git a/runtime/doc/diff.txt b/runtime/doc/diff.txt
index 8c1f03a..6de4bfa 100644
--- a/runtime/doc/diff.txt
+++ b/runtime/doc/diff.txt
@@ -1,4 +1,4 @@
-*diff.txt*      For Vim version 8.1.  Last change: 2019 Jul 27
+*diff.txt*      For Vim version 8.1.  Last change: 2019 Nov 10
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -68,11 +68,12 @@
 The options can still be overruled from a modeline when re-editing the file.
 However, 'foldmethod' and 'wrap' won't be set from a modeline when 'diff' is
 set.
+See `:diffoff` for an easy way to revert the options.
 
 The differences shown are actually the differences in the buffer.  Thus if you
 make changes after loading a file, these will be included in the displayed
 diffs.  You might have to do ":diffupdate" now and then, not all changes are
-immediately taken into account.
+immediately taken into account, especially when using an external diff command.
 
 In your .vimrc file you could do something special when Vim was started in
 diff mode.  You could use a construct like this: >
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 30ec02d..9ba5388 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1,4 +1,4 @@
-*eval.txt*	For Vim version 8.1.  Last change: 2019 Oct 29
+*eval.txt*	For Vim version 8.1.  Last change: 2019 Nov 06
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -1956,11 +1956,15 @@
 
 					*v:mouse_lnum* *mouse_lnum-variable*
 v:mouse_lnum	Line number for a mouse click obtained with |getchar()|.
+		Also used for a click in a popup window when the filter is
+		invoked.
 		This is the text line number, not the screen line number.  The
 		value is zero when there was no mouse button click.
 
 					*v:mouse_col* *mouse_col-variable*
 v:mouse_col	Column number for a mouse click obtained with |getchar()|.
+		Also used for a click in a popup window when the filter is
+		invoked.
 		This is the screen column number, like with |virtcol()|.  The
 		value is zero when there was no mouse button click.
 
diff --git a/runtime/doc/gui.txt b/runtime/doc/gui.txt
index e8ee3f3..362e838 100644
--- a/runtime/doc/gui.txt
+++ b/runtime/doc/gui.txt
@@ -1,4 +1,4 @@
-*gui.txt*       For Vim version 8.1.  Last change: 2019 Aug 21
+*gui.txt*       For Vim version 8.1.  Last change: 2019 Nov 10
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -560,8 +560,9 @@
 				*E330* *E327* *E331* *E336* *E333*
 				*E328* *E329* *E337* *E792*
 To create a new menu item, use the ":menu" commands.  They are mostly like
-the ":map" set of commands but the first argument is a menu item name, given
-as a path of menus and submenus with a '.' between them, e.g.: >
+the ":map" set of commands (see |map-modes|), but the first argument is a menu
+item name, given as a path of menus and submenus with a '.' between them,
+e.g.: >
 
    :menu File.Save  :w<CR>
    :inoremenu File.Save  <C-O>:w<CR>
diff --git a/runtime/doc/map.txt b/runtime/doc/map.txt
index d1202a7..f27c2c1 100644
--- a/runtime/doc/map.txt
+++ b/runtime/doc/map.txt
@@ -1,4 +1,4 @@
-*map.txt*       For Vim version 8.1.  Last change: 2019 Oct 20
+*map.txt*       For Vim version 8.1.  Last change: 2019 Nov 09
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -358,6 +358,8 @@
 :cmap  :cnoremap  :cunmap  :cmapclear	     -	       yes	   -
 :lmap  :lnoremap  :lunmap  :lmapclear	    yes*       yes*	  yes*
 
+* If 'iminsert' is 1, see |language-mapping| below.
+
 The original Vi did not have separate mappings for
 Normal/Visual/Operator-pending mode and for Insert/Command-line mode.
 Therefore the ":map" and ":map!" commands enter and display mappings for
@@ -834,13 +836,21 @@
       let &t_TI = ""
       let &t_TE = ""
 It does not take effect immediately.  To have this work without restarting Vim
-execute a shell command, e.g.: `!ls`
+execute a shell command, e.g.: `!ls`  Or put the lines in your |vimrc|.
+
+When modifyOtherKeys is enabled you can map <C-[> and <C-S-{>: >
+	imap <C-[> [[[
+	imap <C-S-{> {{{
+Without modifyOtherKeys <C-[> and <C-S-{> are indistinguishable from Esc.
 
 A known side effect effect is that in Insert mode the raw escape sequence is
 inserted after the CTRL-V key.  This can be used to check whether
 modifyOtherKeys is enabled: In Insert mode type CTRL-V CTRL-V, if you get
 one byte then modifyOtherKeys is off, if you get <1b>27;5;118~ then it is on.
 
+When the 'esckeys' option is off, then modifyOtherKeys will be disabled in
+Insert mode to avoid every key with a modifier causing Insert mode to end.
+
 
 1.12 MAPPING AN OPERATOR				*:map-operator*
 
diff --git a/runtime/doc/motion.txt b/runtime/doc/motion.txt
index de6b288..8e17ac9 100644
--- a/runtime/doc/motion.txt
+++ b/runtime/doc/motion.txt
@@ -1,4 +1,4 @@
-*motion.txt*    For Vim version 8.1.  Last change: 2019 Nov 01
+*motion.txt*    For Vim version 8.1.  Last change: 2019 Nov 04
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 42c7510..ba96e83 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 8.1.  Last change: 2019 Nov 01
+*options.txt*	For Vim version 8.1.  Last change: 2019 Nov 10
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -5247,6 +5247,8 @@
 	mouse pointer is moved to the window with keyboard focus.  Off is the
 	default because it makes using the pull down menus a little goofy, as
 	a pointer transit may activate a window unintentionally.
+	MS-Windows: Also see 'scrollfocus' for what window is scrolled when
+	using the mouse scroll whel.
 
 			*'mousehide'* *'mh'* *'nomousehide'* *'nomh'*
 'mousehide' 'mh'	boolean	(default on)
@@ -6298,7 +6300,7 @@
 	When using the scroll wheel and this option is set, the window under
 	the mouse pointer is scrolled.  With this option off the current
 	window is scrolled.
-	Systems other than MS-Windows behave like this option is on.
+	Systems other than MS-Windows always behave like this option is on.
 
 						*'scrolljump'* *'sj'*
 'scrolljump' 'sj'	number	(default 1)
@@ -6472,7 +6474,7 @@
 	Environment variables are expanded |:set_env|.
 
 	If the name of the shell contains a space, you need to enclose it in
-	quotes and escape the space.  Example: >
+	quotes and escape the space.  Example with quotes: >
 		:set shell=\"c:\program\ files\unix\sh.exe\"\ -f
 <	Note the backslash before each quote (to avoid starting a comment) and
 	each space (to avoid ending the option value).  Also note that the
diff --git a/runtime/doc/pi_netrw.txt b/runtime/doc/pi_netrw.txt
index 9c8db6b..2189b00 100644
--- a/runtime/doc/pi_netrw.txt
+++ b/runtime/doc/pi_netrw.txt
@@ -1,4 +1,4 @@
-*pi_netrw.txt*  For Vim version 8.1.  Last change: 2019 Oct 10
+*pi_netrw.txt*  For Vim version 8.1.  Last change: 2019 Nov 07
 
 	    ------------------------------------------------
 	    NETRW REFERENCE MANUAL    by Charles E. Campbell
@@ -1184,7 +1184,7 @@
 								*.netrwbook*
 Bookmarks are retained in between sessions of vim in a file called .netrwbook
 as a |List|, which is typically stored in the first directory on the user's
-'runtimepath'; entries are kept in sorted order.
+|'runtimepath'|; entries are kept in sorted order.
 
 If there are marked files and/or directories, mb will add them to the bookmark
 list.
@@ -3512,7 +3512,7 @@
 			- Click "Add..."
 			- Set External Editor (adjust path as needed, include
 			  the quotes and !.! at the end):
-			    "c:\Program Files\Vim\vim81\gvim.exe" !.!
+			    "c:\Program Files\Vim\vim70\gvim.exe" !.!
 			- Check that the filetype in the box below is
 			  {asterisk}.{asterisk} (all files), or whatever types
 			  you want (cec: change {asterisk} to * ; I had to
@@ -3762,8 +3762,8 @@
 
 The <netrw.vim> script is typically installed on systems as something like:
 >
-	/usr/local/share/vim/vim8x/plugin/netrwPlugin.vim
-	/usr/local/share/vim/vim8x/autoload/netrw.vim
+	/usr/local/share/vim/vim7x/plugin/netrwPlugin.vim
+	/usr/local/share/vim/vim7x/autoload/netrw.vim
 		(see output of :echo &rtp)
 <
 which is loaded automatically at startup (assuming :set nocp).  If you
@@ -3842,6 +3842,8 @@
 ==============================================================================
 12. History						*netrw-history* {{{1
 
+	v166:	Nov 06, 2019	* Removed a space from a nmap for "-"
+				* Numerous debugging statement changes
 	v163:	Dec 05, 2017	* (Cristi Balan) reported that a setting ('sel')
 				  was left changed
 				* (Holger Mitschke) reported a problem with
@@ -3852,6 +3854,8 @@
 				* (Holger Mitschke) amended this help file
 				  with additional |g:netrw_special_syntax|
 				  items
+				* Prioritized wget over curl for
+				  g:netrw_http_cmd
 	v162:	Sep 19, 2016	* (haya14busa) pointed out two syntax errors
 				  with a patch; these are now fixed.
 		Oct 26, 2016	* I started using mate-terminal and found that
@@ -4285,4 +4289,4 @@
 
 ==============================================================================
 Modelines: {{{1
- vim:tw=78:ts=8:noet:ft=help:norl:fdm=marker
+ vim:tw=78:ts=8:ft=help:norl:fdm=marker
diff --git a/runtime/doc/quickref.txt b/runtime/doc/quickref.txt
index 76067f5..3b5575f 100644
--- a/runtime/doc/quickref.txt
+++ b/runtime/doc/quickref.txt
@@ -1,4 +1,4 @@
-*quickref.txt*  For Vim version 8.1.  Last change: 2019 Sep 27
+*quickref.txt*  For Vim version 8.1.  Last change: 2019 Nov 07
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -869,6 +869,7 @@
 'runtimepath'	  'rtp'     list of directories used for runtime files
 'scroll'	  'scr'     lines to scroll with CTRL-U and CTRL-D
 'scrollbind'	  'scb'     scroll in window as other windows scroll
+'scrollfocus'	  'scf'     scroll wheel applies to window under pointer
 'scrolljump'	  'sj'	    minimum number of lines to scroll
 'scrolloff'	  'so'	    minimum nr. of lines above and below cursor
 'scrollopt'	  'sbo'     how 'scrollbind' should behave
diff --git a/runtime/doc/tags b/runtime/doc/tags
index f8f5a75..7127692 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -663,7 +663,9 @@
 'nosb'	options.txt	/*'nosb'*
 'nosc'	options.txt	/*'nosc'*
 'noscb'	options.txt	/*'noscb'*
+'noscf'	options.txt	/*'noscf'*
 'noscrollbind'	options.txt	/*'noscrollbind'*
+'noscrollfocus'	options.txt	/*'noscrollfocus'*
 'noscs'	options.txt	/*'noscs'*
 'nosecure'	options.txt	/*'nosecure'*
 'nosft'	options.txt	/*'nosft'*
@@ -843,10 +845,12 @@
 'sbr'	options.txt	/*'sbr'*
 'sc'	options.txt	/*'sc'*
 'scb'	options.txt	/*'scb'*
+'scf'	options.txt	/*'scf'*
 'scl'	options.txt	/*'scl'*
 'scr'	options.txt	/*'scr'*
 'scroll'	options.txt	/*'scroll'*
 'scrollbind'	options.txt	/*'scrollbind'*
+'scrollfocus'	options.txt	/*'scrollfocus'*
 'scrolljump'	options.txt	/*'scrolljump'*
 'scrolloff'	options.txt	/*'scrolloff'*
 'scrollopt'	options.txt	/*'scrollopt'*
@@ -4044,6 +4048,7 @@
 E276	eval.txt	/*E276*
 E277	remote.txt	/*E277*
 E278	popup.txt	/*E278*
+E279	terminal.txt	/*E279*
 E28	syntax.txt	/*E28*
 E280	if_tcl.txt	/*E280*
 E282	starting.txt	/*E282*
diff --git a/runtime/doc/tagsrch.txt b/runtime/doc/tagsrch.txt
index 9c4108f..f0a0097 100644
--- a/runtime/doc/tagsrch.txt
+++ b/runtime/doc/tagsrch.txt
@@ -1,4 +1,4 @@
-*tagsrch.txt*   For Vim version 8.1.  Last change: 2019 Jun 10
+*tagsrch.txt*   For Vim version 8.1.  Last change: 2019 Nov 07
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -436,7 +436,7 @@
 
 Lines in Emacs tags files can be very long.  Vim only deals with lines of up
 to about 510 bytes.  To see whether lines are ignored set 'verbose' to 5 or
-higher.
+higher. Non-Emacs tags file lines can be any length.
 
 							*tags-option*
 The 'tags' option is a list of file names.  Each of these files is searched
diff --git a/runtime/doc/terminal.txt b/runtime/doc/terminal.txt
index 7b40bf2..d83035c 100644
--- a/runtime/doc/terminal.txt
+++ b/runtime/doc/terminal.txt
@@ -1,4 +1,4 @@
-*terminal.txt*	For Vim version 8.1.  Last change: 2019 Nov 01
+*terminal.txt*	For Vim version 8.1.  Last change: 2019 Nov 03
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
diff --git a/runtime/doc/textprop.txt b/runtime/doc/textprop.txt
index 9cf8227..a323d68 100644
--- a/runtime/doc/textprop.txt
+++ b/runtime/doc/textprop.txt
@@ -1,4 +1,4 @@
-*textprop.txt*  For Vim version 8.1.  Last change: 2019 Oct 23
+*textprop.txt*  For Vim version 8.1.  Last change: 2019 Nov 09
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -49,7 +49,7 @@
 how to highlight the text.  The property type can have these entries:
 	"highlight"	name of the highlight group to use
 	"combine"	when TRUE the text property highlighting is combined
-			with any syntax highlighting, when omitted or FALSE the
+			with any syntax highlighting; when omitted or FALSE the
 			text property highlighting replaces the syntax
 			highlighting
 	"priority"	when properties overlap, the one with the highest
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 7147c5c..e36c560 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 8.1.  Last change: 2019 Nov 02
+*todo.txt*      For Vim version 8.1.  Last change: 2019 Nov 10
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -38,29 +38,13 @@
 							*known-bugs*
 -------------------- Known bugs and current work -----------------------
 
-Termdebug:  Ctrl-W . doesn't work with modifyOtherKeys set.
-
-Cannot scroll popup window with mouse in GUI? (#5138)
-
-Add a way to make ":term cmd" run "cmd" in a shell, instead of executing it
-directly.  Perhaps ":term ++shell cmd". (issue #3340)
-
-Include netrw 166a?
-
-In a function these two lines are different:
-    let [a, b, c] =<< trim END      fails
-    let [a,b,c] =<< trim END        works
-issue #5051
-
-Make 'showbreak' global-local.
+Don't use javascriptreact but javascript.jsx?  #4830
+Although there is a good argument against using ".jsx".
 
 Update libvterm on github, rename termscreen.c back to screen.c.
 
-Graduate FEAT_TAG_BINS and make LSIZE for tags bigger.
 
 Popup windows:
-- When using "botleft" for "pos" and there is not enough space, positioning
-  goes below, but this must not happen if there is less space there. #5151
 - Use popup (or popup menu) for command line completion
 - Implement flip option
 - Make redrawing more efficient and avoid flicker:
@@ -143,7 +127,7 @@
   conversions.
 
 Error numbers available:
-E279, E290, E292, E362, E366, E450, E451, E452,
+E290, E292, E362, E366, E450, E451, E452,
 E453, E454, E460, E489, E491, E565, E578, E610, E611, E653,
 E654, E856, E857, E860, E861, E863, E889, E900
 
@@ -189,6 +173,13 @@
 goes to any buffer, and then :bnext skips help buffers, since they are
 unlisted. (#4478)
 
+When 'selection' is "exclusive" then using vi' on the second ' does not select
+anything. (#5183)
+Patch from Christian: 
+https://github.com/chrisbra/vim/commit/7482d1d389e7db97e247f8b509003e5ec27427a9
+When using exclusive selection and vi" that fails, cursor moves to the left.
+Cursor should not move. (#4024)
+
 Enable 'termbidi' if $VTE_VERSION >= 5703 ?
 
 Universal solution to detect if t_RS is working, using cursor position.
@@ -253,6 +244,16 @@
 
 Check_external_diff() is used too often. (Daniel Hahler, #4800)
 
+Win32: after "[I" showing matches, scroll wheel messes up screen. (Tsakiridis,
+2007 Feb 18)
+Patch by Alex Dobrynin, 2007 Jun 3.  Also fixes other scroll wheel problems.
+
+Add a WindowScrolled event.  Trigger around the same time as CursorMoved.
+Can be used to update highlighting. #3127  #5181
+
+Patch for Template string: #4491.  New pull: #4634
+Have another look at the implementation: Is the code worth it?
+
 Incorrect formatting with autoindent. (Sebastian Gniazdowski, #4909)
 
 Patch to add the :bvimgrep command.  (Christian Brabandt, 2014 Nov 12)
@@ -311,6 +312,9 @@
 
 Add an argument to expandcmd() to expand like ":next" does.
 
+When both "a" and "l" is in 'formatoptions' then auto-formatting also happens
+in a long line. #5189
+
 The quoting of the [command] argument of :terminal is not clearly documented.
 Give a few examples. (#4288)
 
@@ -450,9 +454,6 @@
 change.  How does the user know which change?  At least have a way to list
 them: ":repeats".  Add to history, like search history and command line history.
 
-When using exclusive selection and vi" that fails, cursor moves to the left.
-Cursor should not move. (#4024)
-
 Incsearch test fails when locale is "C". (Dominique Pelle, #3986)
 Also run all tests with C locale?
 
@@ -726,9 +727,6 @@
 
 ":bufdo e" disabled syntax HL in windows other than the current. (BPJ)
 
-Patch for Template string: #4491.  New pull: #4634
-It's an awful lot of code for something that is just a bit nicer syntax.
-
 Check argument of systemlist(). (Pavlov)
 
 No maintainer for Vietnamese translations.
@@ -2731,10 +2729,6 @@
 Win32: compiling with normal features and OLE fails.  Patch by Mathias
 Michaelis, 2006 Jun 4.
 
-Win32: after "[I" showing matches, scroll wheel messes up screen. (Tsakiridis,
-2007 Feb 18)
-Patch by Alex Dobrynin, 2007 Jun 3.  Also fixes other scroll wheel problems.
-
 Win32: using CTRL-S in Insert mode doesn't remove the "+" from the tab pages
 label.  (Tsakiridis, 2007 Feb 18)  Patch from Ian Kelling, 2008 Aug 6.
 
diff --git a/runtime/doc/visual.txt b/runtime/doc/visual.txt
index b953dcb..4bf2598 100644
--- a/runtime/doc/visual.txt
+++ b/runtime/doc/visual.txt
@@ -1,4 +1,4 @@
-*visual.txt*    For Vim version 8.1.  Last change: 2019 May 05
+*visual.txt*    For Vim version 8.1.  Last change: 2019 Nov 02
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -116,6 +116,7 @@
 			E.g., "dgn" deletes the text of the next match.
 			If Visual mode is active, extends the selection
 			until the end of the next match.
+			'wrapscan' applies
 			Note: Unlike `n` the search direction does not depend
 			on the previous search command.
 
