diff --git a/runtime/syntax/mail.vim b/runtime/syntax/mail.vim
index eca30f4..a45eb61 100644
--- a/runtime/syntax/mail.vim
+++ b/runtime/syntax/mail.vim
@@ -2,7 +2,7 @@
 " Language:		Mail file
 " Previous Maintainer:	Felix von Leitner <leitner@math.fu-berlin.de>
 " Maintainer:		Gautam Iyer <gautam@math.uchicago.edu>
-" Last Change:		Thu 10 Feb 2005 09:46:26 AM CST
+" Last Change:		2005 Mar 23
 
 " Quit when a syntax file was already loaded
 if exists("b:current_syntax")
@@ -36,14 +36,14 @@
 syn match	mailSubject	contained "\v(^(\> ?)*)@<=subject:.*$"
 
 " Anything in the header between < and > is an email address
-syn match	mailHeaderEmail	contained "<.\{-}>"
+syn match	mailHeaderEmail	contained "<.\{-}>" contains=@NoSpell
 
 " Mail Signatures. (Begin with "-- ", end with change in quote level)
 syn region	mailSignature	keepend contains=@mailLinks,@mailQuoteExps start="^\z(\(> \?\)*\)-- $" end="^\z1$" end="^\z1\@!"me=s-1 end="^\z1\(> \?\)\+"me=s-1
 
 " URLs start with a known protocol or www,web,w3.
-syn match mailURL `\v<(((https?|ftp|gopher)://|(mailto|file|news):)[^' 	<>"]+|(www|web|w3)[a-z0-9_-]*\.[a-z0-9._-]+\.[^' 	<>"]+)[a-z0-9/]`
-syn match mailEmail "\v[_=a-z\./+0-9-]+\@[a-z0-9._-]+\a{2}"
+syn match mailURL `\v<(((https?|ftp|gopher)://|(mailto|file|news):)[^' 	<>"]+|(www|web|w3)[a-z0-9_-]*\.[a-z0-9._-]+\.[^' 	<>"]+)[a-z0-9/]` contains=@NoSpell
+syn match mailEmail "\v[_=a-z\./+0-9-]+\@[a-z0-9._-]+\a{2}" contains=@NoSpell
 
 " Make sure quote markers in regions (header / signature) have correct color
 syn match mailQuoteExp1	contained "\v^(\> ?)"
diff --git a/runtime/syntax/sh.vim b/runtime/syntax/sh.vim
index ac52ce2..ab76273 100644
--- a/runtime/syntax/sh.vim
+++ b/runtime/syntax/sh.vim
@@ -2,8 +2,8 @@
 " Language:		shell (sh) Korn shell (ksh) bash (sh)
 " Maintainer:		Dr. Charles E. Campbell, Jr.  <NdrOchipS@PcampbellAfamily.Mbiz>
 " Previous Maintainer:	Lennart Schultz <Lennart.Schultz@ecmwf.int>
-" Last Change:		Mar 02, 2005
-" Version:		73
+" Last Change:		Mar 24, 2005
+" Version:		74
 " URL:		http://www.erols.com/astronaut/vim/index.html#vimlinks_syntax
 "
 " Using the following VIM variables: {{{1
@@ -169,7 +169,7 @@
 " ====
 syn match   shCaseBar	contained skipwhite "[^|"`'()]\{-}|"hs=e		nextgroup=shCase,shCaseStart,shCaseBar,shComment,shCaseExSingleQuote,shCaseSingleQuote,shCaseDoubleQuote
 syn match   shCaseStart	contained skipwhite skipnl "("			nextgroup=shCase,shCaseBar
-syn region  shCase	contained skipwhite skipnl matchgroup=shSnglCase start="[^$()]\{-})"ms=s,hs=e  end=";;" end="esac"me=s-1 contains=@shCaseList nextgroup=shCaseStart,shCase,,shComment
+syn region  shCase	contained skipwhite skipnl matchgroup=shSnglCase start="[^#$()]\{-})"ms=s,hs=e  end=";;" end="esac"me=s-1 contains=@shCaseList nextgroup=shCaseStart,shCase,,shComment
 syn region  shCaseEsac	matchgroup=shConditional start="\<case\>" end="\<esac\>"	contains=@shCaseEsacList
 syn keyword shCaseIn	contained skipwhite skipnl in			nextgroup=shCase,shCaseStart,shCaseBar,shComment,shCaseExSingleQuote,shCaseSingleQuote,shCaseDoubleQuote
 if exists("b:is_bash")
diff --git a/runtime/syntax/vimspell.vim b/runtime/syntax/vimspell.vim
index 379fe31..4c4149b 100644
--- a/runtime/syntax/vimspell.vim
+++ b/runtime/syntax/vimspell.vim
@@ -1,7 +1,7 @@
 " Vim syntax file
 " Language:	Vim spell file
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2005 Mar 22
+" Last Change:	2005 Mar 24
 
 " Quit when a syntax file was already loaded
 if exists("b:current_syntax")
@@ -11,7 +11,7 @@
 syn match vimspellError		".*"
 syn match vimspellRegion	"^---$"
 syn match vimspellRegion	"^\(-\l\l\)\+$"
-syn match vimspellOK		"^!\=[>+]\=[[:alpha:]]\S*"
+syn match vimspellOK		"^!\=[>+]\=[[:alpha:]].*"
 syn match vimspellOK		"^!\=+\S*"
 syn match vimspellError		"\s\+$"
 syn match vimspellOK		"^$"
