diff --git a/Misc/AIX-NOTES b/Misc/AIX-NOTES
index 613d501..d928f53 100644
--- a/Misc/AIX-NOTES
+++ b/Misc/AIX-NOTES
@@ -22,7 +22,7 @@
 (2) Stefan Esser (se@MI.Uni-Koeln.DE), in work done to compile Python
     1.0.0 on AIX 3.2.4, reports that AIX compilers don't like the LANG
     environment varaiable set to European locales.  This makes the compiler
-    generate floating point constants using "," as the decimal seperator,
+    generate floating point constants using "," as the decimal separator,
     which the assembler doesn't understand (or perhaps it is the other way
     around, with the assembler expecting, but not getting "," in float
     numbers).  "LANG=C; export LANG" solves the problem, as does
diff --git a/Misc/HISTORY b/Misc/HISTORY
index ef33b26..14f283d 100644
--- a/Misc/HISTORY
+++ b/Misc/HISTORY
@@ -9862,7 +9862,7 @@
 	Also (quite separately, but strangely related to the philosophical
 	issue above) fix abspath() so that if win32api exists, it doesn't fail
 	when the path doesn't actually exist -- if GetFullPathName() fails,
-	fall back on the old strategy (join with getcwd() if neccessary, and
+	fall back on the old strategy (join with getcwd() if necessary, and
 	then use normpath()).
 
 	* configure.in, configure, config.h.in, acconfig.h:
diff --git a/Misc/NEWS b/Misc/NEWS
index 1ba1a73..7b869b5 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -1087,7 +1087,7 @@
 - Issue #3575: Incremental decoder's decode function now takes bytearray
   by using 's*' instead of 't#'.
 
-- Issue #2222: Fixed reference leak when occured os.rename()
+- Issue #2222: Fixed reference leak when occurred os.rename()
   fails unicode conversion on 2nd parameter. (windows only)
 
 - Issue 2464. urllib2 now supports a malformation in the URL received
diff --git a/Misc/cheatsheet b/Misc/cheatsheet
index cb0702a..df69f24 100644
--- a/Misc/cheatsheet
+++ b/Misc/cheatsheet
@@ -481,7 +481,7 @@
 s.isupper()       return True if all characters in s are uppercase, False  (6)
                   otherwise.
 s.join(seq)       return a concatenation of the strings in the sequence
-                  seq, seperated by 's's.
+                  seq, separated by 's's.
 s.ljust(width)    return s left justified in a string of length width.    (1),
                                                                            (8)
 s.lower()         return a copy of s converted to lowercase.
@@ -1556,10 +1556,10 @@
 asctime(
 timeTuple),
 strftime(
-format,       return a formated string representing time.
+format,       return a formatted string representing time.
 timeTuple)
 mktime(tuple) inverse of localtime(). Return a float.
-strptime(     parse a formated string representing time, return tuple as in
+strptime(     parse a formatted string representing time, return tuple as in
 string[,      gmtime().
 format])
 sleep(secs)   Suspend execution for <secs> seconds. <secs> can be a float.
