diff --git a/runtime/doc/builtin.txt b/runtime/doc/builtin.txt
index 32167d6..5d9a436 100644
--- a/runtime/doc/builtin.txt
+++ b/runtime/doc/builtin.txt
@@ -1,4 +1,4 @@
-*builtin.txt*	For Vim version 9.1.  Last change: 2024 Oct 14
+*builtin.txt*	For Vim version 9.1.  Last change: 2024 Oct 16
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -11954,7 +11954,7 @@
 		For example to make <c-j> work like <down> in wildmode, use: >
     :cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
 <
-		(Note, this needs the 'wildcharm' option set appropriately).
+		(Note: this needs the 'wildcharm' option set appropriately).
 
 		Return type: |Number|
 
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 40dc139..075d3ee 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 9.1.  Last change: 2024 Oct 14
+*options.txt*	For Vim version 9.1.  Last change: 2024 Oct 16
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -8705,7 +8705,9 @@
 	be restored if possible, see |X11|.
 
 	When this option contains printf-style '%' items, they will be
-	expanded according to the rules used for 'statusline'.
+	expanded according to the rules used for 'statusline'.  If it contains
+	an invalid '%' format, the value is used as-is and no error or warning
+	will be given when the value is set.
 	This option cannot be set in a modeline when 'modelineexpr' is off.
 
 	Example: >
diff --git a/runtime/syntax/help.vim b/runtime/syntax/help.vim
index 68f68c2..ae7e3bc 100644
--- a/runtime/syntax/help.vim
+++ b/runtime/syntax/help.vim
@@ -57,6 +57,7 @@
   syn match helpIgnore		"." contained
 endif
 syn keyword helpNote		note Note NOTE note: Note: NOTE: Notes Notes:
+syn match helpNote		"\c(note\(:\|\>\)"ms=s+1
 syn keyword helpWarning		WARNING WARNING: Warning:
 syn keyword helpDeprecated	DEPRECATED DEPRECATED: Deprecated:
 syn match helpSpecial		"\<N\>"
@@ -69,6 +70,10 @@
 syn match helpSpecial		"N  N"he=s+1
 syn match helpSpecial		"Nth"me=e-2
 syn match helpSpecial		"N-1"me=e-2
+" highlighting N for :resize in windows.txt
+syn match helpSpecial		"] -N\>"ms=s+3
+syn match helpSpecial		"+N\>"ms=s+1
+syn match helpSpecial		"\[+-]N\>"ms=s+4
 " highlighting N of cinoptions-values in indent.txt
 syn match helpSpecial		"^\t-\?\zsNs\?\s"me=s+1
 " highlighting N of cinoptions-values in indent.txt
@@ -145,7 +150,7 @@
 syn match helpError		"\t[* ]Error\t\+[a-z].*"
 syn match helpTodo		"\t[* ]Todo\t\+[a-z].*"
 
-syn match helpURL `\v<(((https?|ftp|gopher)://|(mailto|file|news):)[^' 	<>"]+|(www|web|w3)[a-z0-9_-]*\.[a-z0-9._-]+\.[^' 	<>"]+)[a-zA-Z0-9/]`
+syn match helpURL `\v<(((https?|ftp|gopher)://|(mailto|file|news):)[^'" \t<>{}]+|(www|web|w3)[a-z0-9_-]*\.[a-z0-9._-]+\.[^'" \t<>{}]+)[a-zA-Z0-9/]`
 
 syn match helpDiffAdded		"\t[* ]Added\t\+[a-z].*"
 syn match helpDiffChanged	"\t[* ]Changed\t\+[a-z].*"
@@ -157,17 +162,6 @@
   exe "runtime syntax/help_" . strpart(expand("%"), s:i + 1, 2) . ".vim"
 endif
 
-" Italian
-if v:lang =~ '\<IT\>' || v:lang =~ '_IT\>' || v:lang =~? "italian"
-  syn keyword helpNote		nota Nota NOTA nota: Nota: NOTA: notare Notare NOTARE notare: Notare: NOTARE:
-  syn match helpSpecial		"Nma"me=e-2
-  syn match helpSpecial		"Nme"me=e-2
-  syn match helpSpecial		"Nmi"me=e-2
-  syn match helpSpecial		"Nmo"me=e-2
-  syn match helpSpecial		"\[interv.]"
-  syn region helpNotVi		start="{non" start="{solo" start="{disponibile" end="}" contains=helpLeadBlank,helpHyperTextJump
-endif
-
 syn sync minlines=40
 
 
diff --git a/runtime/syntax/help_it.vim b/runtime/syntax/help_it.vim
new file mode 100644
index 0000000..e76851d
--- /dev/null
+++ b/runtime/syntax/help_it.vim
@@ -0,0 +1,17 @@
+" Vim syntax file
+" Language:	Italian Vim program help files *.itx
+" Maintainer:	The Vim Project <https://github.com/vim/vim>
+" Last Change:	2024 Oct 16
+"
+" This script is sourced from syntax/help.vim.
+
+syn keyword helpNote		nota Nota NOTA nota: Nota: NOTA: notare Notare NOTARE notare: Notare: NOTARE:
+syn match helpNote		"\c(nota\(:\|\>\)"ms=s+1
+syn match helpSpecial		"Nma"me=e-2
+syn match helpSpecial		"Nme"me=e-2
+syn match helpSpecial		"Nmi"me=e-2
+syn match helpSpecial		"Nmo"me=e-2
+syn match helpSpecial		"\[interv.]"
+syn region helpNotVi		start="{non" start="{solo" start="{disponibile" end="}" contains=helpLeadBlank,helpHyperTextJump
+
+" vim: ts=8 sw=2
