diff --git a/Doc/info/texipre.dat b/Doc/info/texipre.dat
index f8cc166..20f60a4 100644
--- a/Doc/info/texipre.dat
+++ b/Doc/info/texipre.dat
@@ -77,7 +77,7 @@
 Reference Manual} gives a more formal definition of the language.
 (These manuals are not yet available in INFO or Texinfo format.)
 
-This version corresponds to Python version 1.0.2.
+This version corresponds to Python version 1.1.
 
 @end ifinfo
 
diff --git a/Doc/texipre.dat b/Doc/texipre.dat
index f8cc166..20f60a4 100644
--- a/Doc/texipre.dat
+++ b/Doc/texipre.dat
@@ -77,7 +77,7 @@
 Reference Manual} gives a more formal definition of the language.
 (These manuals are not yet available in INFO or Texinfo format.)
 
-This version corresponds to Python version 1.0.2.
+This version corresponds to Python version 1.1.
 
 @end ifinfo
 
diff --git a/Doc/tut.tex b/Doc/tut.tex
index 6a1bcd9..bcaa058 100644
--- a/Doc/tut.tex
+++ b/Doc/tut.tex
@@ -213,7 +213,7 @@
 
 \bcode\begin{verbatim}
 python
-Python 1.0.3 (Jul 14 1994)
+Python 1.1 (Oct  6 1994)
 Copyright 1991-1994 Stichting Mathematisch Centrum, Amsterdam
 >>>
 \end{verbatim}\ecode
diff --git a/Doc/tut/tut.tex b/Doc/tut/tut.tex
index 6a1bcd9..bcaa058 100644
--- a/Doc/tut/tut.tex
+++ b/Doc/tut/tut.tex
@@ -213,7 +213,7 @@
 
 \bcode\begin{verbatim}
 python
-Python 1.0.3 (Jul 14 1994)
+Python 1.1 (Oct  6 1994)
 Copyright 1991-1994 Stichting Mathematisch Centrum, Amsterdam
 >>>
 \end{verbatim}\ecode
