diff --git a/runtime/doc/change.txt b/runtime/doc/change.txt
index 6ccf93d..6dd20ad 100644
--- a/runtime/doc/change.txt
+++ b/runtime/doc/change.txt
@@ -1,4 +1,4 @@
-*change.txt*    For Vim version 7.4.  Last change: 2015 Oct 17
+*change.txt*    For Vim version 7.4.  Last change: 2016 Jan 02
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -438,8 +438,8 @@
   index.
 
 For decimals a leading negative sign is considered for incrementing/
-decrementing, for octal and hex values, it won't be considered.
-To ignore the sign Visually select the number before using CTRL-A or CTRL-X. 
+decrementing, for binary, octal and hex values, it won't be considered.  To
+ignore the sign Visually select the number before using CTRL-A or CTRL-X. 
 
 For numbers with leading zeros (including all octal and hexadecimal numbers),
 Vim preserves the number of characters in the number when possible.  CTRL-A on
@@ -1007,7 +1007,7 @@
 
 :reg[isters] {arg}	Display the contents of the numbered and named
 			registers that are mentioned in {arg}.  For example: >
-				:dis 1a
+				:reg 1a
 <			to display registers '1' and 'a'.  Spaces are allowed
 			in {arg}.  {not in Vi}
 
diff --git a/runtime/doc/editing.txt b/runtime/doc/editing.txt
index 4c013e9..307e20d 100644
--- a/runtime/doc/editing.txt
+++ b/runtime/doc/editing.txt
@@ -1,4 +1,4 @@
-*editing.txt*   For Vim version 7.4.  Last change: 2015 Aug 25
+*editing.txt*   For Vim version 7.4.  Last change: 2016 Jan 03
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -1105,7 +1105,7 @@
 			the last file in the argument list has not been
 			edited.  See |:confirm| and 'confirm'.  {not in Vi}
 
-:q[uit]!		Quit without writing, also when currentl buffer has
+:q[uit]!		Quit without writing, also when the current buffer has
 			changes.  If this is the last window and there is a
 			modified hidden buffer, the current buffer is
 			abandoned and the first changed hidden buffer becomes
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 9a09060..e40116b 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1,4 +1,4 @@
-*eval.txt*	For Vim version 7.4.  Last change: 2015 Dec 29
+*eval.txt*	For Vim version 7.4.  Last change: 2016 Jan 02
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -68,14 +68,16 @@
 	Number 0	-->	String "0" ~
 	Number -1	-->	String "-1" ~
 							*octal*
-Conversion from a String to a Number is done by converting the first digits
-to a number.  Hexadecimal "0xf9" and Octal "017" numbers are recognized.  If
-the String doesn't start with digits, the result is zero.  Examples:
+Conversion from a String to a Number is done by converting the first digits to
+a number.  Hexadecimal "0xf9", Octal "017", and Binary "0b10" numbers are
+recognized.  If the String doesn't start with digits, the result is zero.
+Examples:
 	String "456"	-->	Number 456 ~
 	String "6bar"	-->	Number 6 ~
 	String "foo"	-->	Number 0 ~
 	String "0xf1"	-->	Number 241 ~
 	String "0100"	-->	Number 64 ~
+	String "0b101"	-->	Number 5 ~
 	String "-8"	-->	Number -8 ~
 	String "+8"	-->	Number 0 ~
 
@@ -5955,12 +5957,14 @@
 
 str2nr( {expr} [, {base}])				*str2nr()*
 		Convert string {expr} to a number.
-		{base} is the conversion base, it can be 8, 10 or 16.
+		{base} is the conversion base, it can be 2, 8, 10 or 16.
 		When {base} is omitted base 10 is used.  This also means that
 		a leading zero doesn't cause octal conversion to be used, as
 		with the default String to Number conversion.
 		When {base} is 16 a leading "0x" or "0X" is ignored.  With a
-		different base the result will be zero.
+		different base the result will be zero.  Similarly, when
+		{base} is 8 a leading "0" is ignored, and when {base} is 2 a
+		leading "0b" or "0B" is ignored.
 		Text after the number is silently ignored.
 
 
diff --git a/runtime/doc/if_tcl.txt b/runtime/doc/if_tcl.txt
index d6726a3..bc9d3b8 100644
--- a/runtime/doc/if_tcl.txt
+++ b/runtime/doc/if_tcl.txt
@@ -1,4 +1,4 @@
-*if_tcl.txt*    For Vim version 7.4.  Last change: 2012 Aug 02
+*if_tcl.txt*    For Vim version 7.4.  Last change: 2016 Jan 01
 
 
 		  VIM REFERENCE MANUAL    by Ingo Wilken
@@ -526,7 +526,7 @@
 console window type "path" to see what directories are used.
 
 The name of the DLL must match the Tcl version Vim was compiled with.
-Currently the name is "tcl83.dll".  That is for Tcl 8.3.  To know for sure
+Currently the name is "tcl86.dll".  That is for Tcl 8.6.  To know for sure
 edit "gvim.exe" and search for "tcl\d*.dll\c".
 
 ==============================================================================
diff --git a/runtime/doc/index.txt b/runtime/doc/index.txt
index ded50d0..109d89a 100644
--- a/runtime/doc/index.txt
+++ b/runtime/doc/index.txt
@@ -1,4 +1,4 @@
-*index.txt*     For Vim version 7.4.  Last change: 2015 Sep 08
+*index.txt*     For Vim version 7.4.  Last change: 2016 Jan 03
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -1495,6 +1495,7 @@
 |:smap|		:smap		like ":map" but for Select mode
 |:smapclear|	:smapc[lear]	remove all mappings for Select mode
 |:smenu|	:sme[nu]	add menu for Select mode
+|:smile|        :smi[le]	make the user happy
 |:snext|	:sn[ext]	split window and go to next file in the
 				argument list
 |:sniff|	:sni[ff]	send request to sniff
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index c813bc7..a2c13ac 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 7.4.  Last change: 2015 Nov 23
+*options.txt*	For Vim version 7.4.  Last change: 2016 Jan 03
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -4603,7 +4603,7 @@
 			feature}
 	This option allows switching your keyboard into a special language
 	mode.  When you are typing text in Insert mode the characters are
-	inserted directly.  When in command mode the 'langmap' option takes
+	inserted directly.  When in Normal mode the 'langmap' option takes
 	care of translating these special characters to the original meaning
 	of the key.  This means you don't have to change the keyboard mode to
 	be able to execute Normal mode commands.
@@ -5019,8 +5019,11 @@
 			{not in Vi}
 	Maximum amount of memory in Kbyte to use for all buffers together.
 	The maximum usable value is about 2000000 (2 Gbyte).  Use this to work
-	without a limit.  On 64 bit machines higher values might work.  But
-	hey, do you really need more than 2 Gbyte for text editing?
+	without a limit.
+	On 64 bit machines higher values might work.  But hey, do you really
+	need more than 2 Gbyte for text editing?  Keep in mind that text is
+	stored in the swap file, one can edit files > 2 Gbyte anyay.  We do
+	need the memory to store undo info.
 	Also see 'maxmem'.
 
 						*'menuitems'* *'mis'*
@@ -6838,7 +6841,8 @@
 	the two-letter, lower case region name.  You can use more than one
 	region by listing them: "en_us,en_ca" supports both US and Canadian
 	English, but not words specific for Australia, New Zealand or Great
-	Britain.
+	Britain. (Note: currently en_au and en_nz dictionaries are older than
+	en_ca, en_gb and en_us).
 	If the name "cjk" is included East Asian characters are excluded from
 	spell checking.  This is useful when editing text that also has Asian
 	words.
diff --git a/runtime/doc/pattern.txt b/runtime/doc/pattern.txt
index 0a85322..2a3d2c4 100644
--- a/runtime/doc/pattern.txt
+++ b/runtime/doc/pattern.txt
@@ -1,4 +1,4 @@
-*pattern.txt*   For Vim version 7.4.  Last change: 2015 Dec 26
+*pattern.txt*   For Vim version 7.4.  Last change: 2016 Jan 03
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -1102,7 +1102,10 @@
 	  plausible pattern for a UNIX filename: "[-./[:alnum:]_~]\+" That is,
 	  a list of at least one character, each of which is either '-', '.',
 	  '/', alphabetic, numeric, '_' or '~'.
-	  These items only work for 8-bit characters.
+	  These items only work for 8-bit characters, except [:lower:] and
+	  [:upper:] also work for multi-byte characters when using the new
+	  regexp engine.  In the future these items may work for multi-byte
+	  characters.
 							*/[[=* *[==]*
 	- An equivalence class.  This means that characters are matched that
 	  have almost the same meaning, e.g., when ignoring accents.  This
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 50f5b9a..382a83f 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -7459,7 +7459,6 @@
 or()	eval.txt	/*or()*
 oracle	ft_sql.txt	/*oracle*
 os2	os_os2.txt	/*os2*
-os2ansi	os_os2.txt	/*os2ansi*
 os390	os_390.txt	/*os390*
 os_390.txt	os_390.txt	/*os_390.txt*
 os_amiga.txt	os_amiga.txt	/*os_amiga.txt*
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index d6503cc..b8bfe61 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 7.4.  Last change: 2015 Dec 29
+*todo.txt*      For Vim version 7.4.  Last change: 2016 Jan 03
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -76,30 +76,10 @@
   matches the empty string. (Dominique Pelle, 2015 Oct 2, Nov 24)
 - Search for \\~ causes error E874.
 
-Poor mans runtime file updater:
-- Generate a content file of all included runtime files:
-    $VIMRUNTIME/CONTENTS
-  With lines:
-        runtime/syntax/ada.vim hexchecksum  hexchecksum-with-CR-LF
-	runtime/syntax/old.vim DELETED
-- Use a command to trigger a script:
-	:RuntimeUpdate
-  Gets the new contents file from
-    https://raw.githubusercontent.com/vim/vim/master/runtime/CONTENTS
-  Goes over each line, compares the checksum and gets the file if it differs.
-- Include a minimal required Vim version?
-- For an installation, use "sudo" after getting all the files, only copy them.
-   need a temp directory tree.
-- For Windows generate a .bat file with "runas" (see StackOverflow).
-- Include a wget.exe or curl.exe in the distribution?
-- Also update vim.exe and gvim.exe this way?
-
-English spell file has an encoding error in the affix file.
-(Dominique Pelle, 2015 Oct 15)
-Perhaps use the files from here:
-https://github.com/marcoagpinto/aoo-mozilla-en-dict
-Hint for new URL: Christian Brabandt, 2015 Oct 15.
-But that file looks old.
+Need better instructions about how to install all interfaces and how to build
+Vim with them.
+For Ruby: https://github.com/ruby/ruby/tree/trunk/win32
+Or use Ken Takata's hack.
 
 Still using freed memory after using setloclist(). (lcd, 2014 Jul 23)
 More info Jul 24.  Not clear why.
@@ -116,86 +96,35 @@
 Or use $XDG_DATA_DIRS.
 Also need to run update-desktop-database (Kuriyama Kazunobu, 2015 Nov 4)
 
-Patch to test shadow. James McCoy, 2015 Dec 7, #520
-
-Patch to support strawberry Perl. (Ken Takata, 2015 Dec 21)
-
-Change the travis config to also run autoconf on the huge build.
-(James McCoy, 2015 Dec 4)
-
 Access to uninitialized memory in match_backref() regexp_nda.c:4882
 (Dominique Pelle, 2015 Nov 6)
 
-Patch to fix test_listchars for MingW. (Christian Brabandt, 2015 Nov 29)
-
-Patch to not set the python home if $PYTHONHOME is set. (Kazuki Sakamoto,
-2015 Nov 24)
-
-Patch to add tests for what 7.3.192 fixed. (Elias Diem, 2015 Dec 22)
-
-Patch to use local value of 'errorformat' in :cexpr. (Christian Brabandt,
-2015 Oct 16)  Only do this for :lexpr ?
-
 ":cd C:\Windows\System32\drivers\etc*" does not work, even though the
 directory exists. (Sergio Gallelli, 2013 Dec 29)
 
-Patch to make fnamemodify() work better with Cygwin. (Wily Wampa == Jacob
-Niehus, 2015 Nov 28, issue 505) 
-
-Patch to fix mc_FullName() on root directory. (Milly, 2015 Nov 24, Issue 501)
-
-Patch to make matchparen restore curswant properly. (Christian Brabandt, 2015
-Nov 26)
-
-Test 17 does not clean up the directory it creates. (Michael Soyka, 2015 Nov
-28)
-
-Patch to add binary support for nrformat. (Jason Schulz, 2015 Dec 28)
-
-Patch to make assert_false() error message look better. (Watiko, 2015 Dec 14)
-
 Using ":windo" to set options in all windows has the side effect that it
 changes the window layout and the current window.  Make a variant that saves
 and restores.  Use in the matchparen plugin.
 Perhaps we can use "window <restore> {cmd}"?
 
-Patch to estimate available memory on MS-Windows. (Mike Williams, 2015 Dec 18)
-Last version that day.
-
 Illegal memory access, requires ASAN to see. (Dominique Pelle, 2015 Jul 28)
 
-Patch for testing 'backspace'.  Also changes behavior of ":set bs=0", do we
-want that? (Hirohito Higashi, 2015 Dec 17)
-New patch Dec 26.
-
-Patch to adjust an Ex range only if it's about line numbers. (Christian
-Brabandt, 2015 Dec 13)
-
 Gvim: when both Tab and CTRL-I are mapped, use CTRL-I not for Tab.
 
 Unexpected delay when using CTRL-O u.  It's not timeoutlen.
 (Gary Johnson, 2015 Aug 28)
 
-Patch for tee on Windows. (Yasuhiro Matsumoto, 2015 Nov 30)
-Update Dec 1.
-
-Patch to use 256 color setup for all terminals that have 256 colors or more.
-#504. (rdebath, 2015 Dec 1)
-
 Instead of separately uploading patches to the ftp site, can we get them from
 github?  This URL works:
    https://github.com/vim/vim/compare/v7.4.920%5E...v7.4.920.diff
+Diff for version.c contains more context, can't skip a patch.
 >
 Can src/GvimExt/Make_cyg.mak be removed?
 Same for src/xxd/Make_cyg.mak
 
-":q!" should reset modified flag for current buffer, if another buffer is
-modified no need to abandon it again.
-Patch from Yasuhiro Matsumoto, 2014 Nov 21.
-Update from Hirohito Higashi, 2014 Nov 21.
-With test, Nov 23.  Update 2015 Dec 15.
-
-Updated Fortran files. (Ajit Thakkar, 2015 Nov 30, second one)
+When t_Co is changed from termresponse, the OptionSet autocmmand event isn't
+triggered.  Use the code from the end of set_num_option() in
+set_color_count().
 
 Python: ":py raw_input('prompt')" doesn't work. (Manu Hack)
 
@@ -209,7 +138,7 @@
 (Hirohito Higashi, 2015 Nov 24)
 
 Patch to add debug backtrace. (Alberto Fanjul, 2015 Sep 27)
-Update Dec 2.
+Update 2016 Jan 2.  Issue #433
 
 MS-Windows: When editing a file with a leading space, writing it uses the
 wrong name. (Aram, 2014 Nov 7)  Vim 7.4.
@@ -237,11 +166,6 @@
 
 Patch to add window and tab arguments to getcwd(). (Thinca, 2015 Nov 15)
 
-Patch to check PYTHONHOME first. #500
-
-Patch to build with Python using MSYS2. (Yasuhiro Matsumoto, 2015 Nov 26)
-Updated Nov 29.
-
 Build with Python on Mac does not always use the right library.
 (Kazunobu Kuriyama, 2015 Mar 28)
 
@@ -324,7 +248,14 @@
 
 Patch for multi-byte characters in langmap and applying a mapping on them.
 (Christian Brabandt, 2015 Jun 12, update July 25)
-Is this the right solution?
+Is this the right solution?  Need to cleanup langmap behavior:
+- in vgetorpeek() apply langmap to the typeahead buffer and put the result in
+  a copy-buffer, only when langmap is appropriate for the current mode. Then
+  check for mapping and let gotchars() work on the copy-buffer.
+- Remove LANGMAP_ADJUST() in other parts of the code.  Make sure the mode is
+  covered by the above change.
+So that replaying the register doesn't use keymap/langmap and still does the
+same thing.  Remarks on issue 543.
 
 Patch to add grepfile(). (Scott Prager, 2015 May 26)
 Work in progress.
@@ -716,6 +647,18 @@
 
 Dialog is too big on Linux too. (David Fishburn, 2013 Sep 2)
 
+Improve the installer for MS-Windows.  There are a few alternatives:
+- Installer from Cream (Steve Hall).
+- Modern UI 2.0 for the Nsis installer. (Guopeng Wen)
+    https://github.com/gpwen/vim-installer-mui2
+-  make it possible to do a silent install, see
+    http://nsis.sourceforge.net/Docs/Chapter4.html#4.12
+    Version from Guopeng Wen does this.
+- MSI installer: https://github.com/petrkle/vim-msi/
+- The one on Issue 279.
+Problem: they all work slightly different (e.g. don't install vimrun.exe).
+How to test that it works well for all Vim users?
+
 Patch to check whether a buffer is quickfix or a location list.
 (Yasuhiro Matsumoto, 2014 Dec 9)
 
@@ -809,14 +752,6 @@
   causes the window to move unnecessarily. (William E. Skeith III, 2012 Jan
   12) Patch: 2012 Jan 13  Needs more work (2012 Feb 2)
 
-Patch to use Modern UI 2.0 for the Nsis installer. (Guopeng Wen, 2010 Jul 30)
-Latest version: 2011 May 18 
-8   Windows install with NSIS: make it possible to do a silent install, see
-    http://nsis.sourceforge.net/Docs/Chapter4.html#4.12
-    Version from Guopeng Wen that does this (2010 Dec 27)
-Alternative: MSI installer: https://github.com/petrkle/vim-msi/
-Or the one on Issue 279
-
 'iminsert' global value set when using ":setlocal iminsert"? (Wu, 2012 Jun 23)
 
 Patch to append regexp to tag commands to make it possible to select one out
@@ -936,9 +871,9 @@
 Win32: Cannot cd into a directory that starts with a space. (Andy Wokula, 2012
 Jan 19)
 
-Need to escape $HOME on Windows?  (ZyX, 2011 Jul 21, discussion 2013 Jul 4)
-Can't simply use a backslash, \$HOME has a different meaning already.
-Would be possible to use $$HOME where $HOME is to be used.
+Need to escape $HOME on Windows for fnameescape()?  (ZyX, 2011 Jul 21,
+discussion 2013 Jul 4) Can't simply use a backslash, \$HOME has a different
+meaning already.  Would be possible to use $$HOME where $HOME is to be used.
 
 "2" in 'formatoptions' not working in comments. (Christian Corneliussen, 2011
 Oct 26)
diff --git a/runtime/doc/version5.txt b/runtime/doc/version5.txt
index 1cc6a25..e47fa43 100644
--- a/runtime/doc/version5.txt
+++ b/runtime/doc/version5.txt
@@ -1,4 +1,4 @@
-*version5.txt*  For Vim version 7.4.  Last change: 2012 Aug 08
+*version5.txt*  For Vim version 7.4.  Last change: 2016 Jan 03
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -848,7 +848,7 @@
 
 After recovery, BufReadPost autocommands are applied.  |:recover|
 
-Added color support for "os2ansi", OS/2 console. (Slootman) |os2ansi|
+Added color support for "os2ansi", OS/2 console. (Slootman)
 
 Allow "%:p:h" when % is empty.  |:_%|
 
