diff --git a/runtime/doc/filetype.txt b/runtime/doc/filetype.txt
index 0dfdff8..252551c 100644
--- a/runtime/doc/filetype.txt
+++ b/runtime/doc/filetype.txt
@@ -1,4 +1,4 @@
-*filetype.txt*	For Vim version 9.1.  Last change: 2024 Sep 29
+*filetype.txt*	For Vim version 9.1.  Last change: 2024 Oct 05
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -776,7 +776,7 @@
 
 Local mappings:
 <Plug>ManBS
-<LocalLeader>h	Clear backspace <BS> characters from the buffer
+<LocalLeader>h	Clear backspace <BS> characters from the buffer.
 CTRL-]		Jump to the manual page for the word under the cursor.
 CTRL-T		Jump back to the previous manual page.
 
diff --git a/runtime/doc/pi_getscript.txt b/runtime/doc/pi_getscript.txt
index 5f86384..869314c 100644
--- a/runtime/doc/pi_getscript.txt
+++ b/runtime/doc/pi_getscript.txt
@@ -1,4 +1,4 @@
-*pi_getscript.txt*  For Vim version 9.1.  Last change: 2024 Sep 27
+*pi_getscript.txt*  For Vim version 9.1.  Last change: 2024 Oct 05
 >
 		GETSCRIPT REFERENCE MANUAL  by Charles E. Campbell
 <
@@ -281,14 +281,14 @@
 
 	---.tar.bz2  : decompressed & untarred in .vim/ directory
 	---.vba.bz2  : decompressed in .vim/ directory, then vimball handles it
-	---.vmb.bz2  : decompressed in .vim/ directory, then vimball handles it
+	---.vmb.bz2  : idem
 	---.vim.bz2  : decompressed & moved into .vim/plugin directory
 	---.tar.gz   : decompressed & untarred in .vim/ directory
 	---.vba.gz   : decompressed in .vim/ directory, then vimball handles it
-	---.vmb.gz   : decompressed in .vim/ directory, then vimball handles it
+	---.vmb.gz   : idem
 	---.vim.gz   : decompressed & moved into .vim/plugin directory
 	---.vba      : moved to .vim/ directory, then vimball handles it
-	---.vmb      : moved to .vim/ directory, then vimball handles it
+	---.vmb      : idem
 	---.vim      : moved to .vim/plugin directory
 	---.zip      : unzipped in .vim/ directory
 
diff --git a/runtime/doc/starting.txt b/runtime/doc/starting.txt
index 84bf30f..7ce4d6f 100644
--- a/runtime/doc/starting.txt
+++ b/runtime/doc/starting.txt
@@ -1,4 +1,4 @@
-*starting.txt*  For Vim version 9.1.  Last change: 2024 Sep 15
+*starting.txt*  For Vim version 9.1.  Last change: 2024 Oct 05
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -847,7 +847,8 @@
 	'compatible' is only done later.  Add a ":set nocp" command if you
 	like.  For the Macintosh the $VIMRUNTIME/macmap.vim is read.
 
-	  *VIMINIT* *.vimrc* *_vimrc* *EXINIT* *.exrc* *_exrc* *$MYVIMRC* *$MYVIMDIR*
+			*VIMINIT* *.vimrc* *_vimrc* *EXINIT* *.exrc* *_exrc*
+			*$MYVIMRC* *$MYVIMDIR*
      c. Five places are searched for initializations.  The first that exists
 	is used, the others are ignored.  The $MYVIMRC environment variable is
 	set to the file that was first found, unless $MYVIMRC was already set
@@ -972,9 +973,9 @@
 	The |v:vim_did_enter| variable is set to 1.
 	The |VimEnter| autocommands are executed.
 
-The $MYVIMRC or $MYGVIMRC file will be set to the first found vimrc and/or
-gvimrc file while $MYVIMDIR is set to the users personal runtime directory
-'rtp' (typically the first entry in 'runtimepath').
+The $MYVIMRC or $MYGVIMRC environment variable will be set to the first found
+vimrc and/or gvimrc file while $MYVIMDIR is set to the users personal runtime
+directory 'rtp' (typically the first entry in 'runtimepath').
 
 
 Some hints on using initializations ~
diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index ff80936..286dcbb 100644
--- a/runtime/doc/syntax.txt
+++ b/runtime/doc/syntax.txt
@@ -1,4 +1,4 @@
-*syntax.txt*	For Vim version 9.1.  Last change: 2024 Sep 28
+*syntax.txt*	For Vim version 9.1.  Last change: 2024 Oct 05
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -2196,7 +2196,7 @@
 
 
 JSON			*json.vim* *ft-json-syntax* *g:vim_json_conceal*
-					       *g:vim_json_warnings*
+						*g:vim_json_warnings*
 
 The json syntax file provides syntax highlighting with conceal support by
 default. To disable concealment: >
diff --git a/runtime/doc/usr_toc.txt b/runtime/doc/usr_toc.txt
index c70c945..3da7698 100644
--- a/runtime/doc/usr_toc.txt
+++ b/runtime/doc/usr_toc.txt
@@ -1,8 +1,8 @@
-*usr_toc.txt*	For Vim version 9.1.  Last change: 2024 Oct 01
+*usr_toc.txt*	For Vim version 9.1.  Last change: 2024 Oct 05
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
-			      Table Of Contents		       *user-manual* *usr*
+			      Table Of Contents		*user-manual* *usr*
 
 ==============================================================================
 Overview ~
diff --git a/runtime/doc/version9.txt b/runtime/doc/version9.txt
index d684b49..56bb7e2 100644
--- a/runtime/doc/version9.txt
+++ b/runtime/doc/version9.txt
@@ -1,4 +1,4 @@
-*version9.txt*  For Vim version 9.1.  Last change: 2024 Oct 01
+*version9.txt*  For Vim version 9.1.  Last change: 2024 Oct 05
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -41608,7 +41608,7 @@
 |diff()|		diff two Lists of strings
 |filecopy()|		copy a file {from} to {to}
 |foreach()|		apply function to List items
-|getcmdprompt()|        get prompt for input()/confirm()
+|getcmdprompt()|	get prompt for input()/confirm()
 |getregion()|		get a region of text from a buffer
 |getregionpos()|	get a list of positions for a region
 |id()|			get unique identifier for a Dict, List, Object,
