diff --git a/Doc/Makefile b/Doc/Makefile
index 9a32058..e609518 100644
--- a/Doc/Makefile
+++ b/Doc/Makefile
@@ -6,9 +6,14 @@
 # This is a bit of a mess.  The main documents are:
 #   tut -- Tutorial (file tut.tex)
 #   lib -- Library Reference (file lib.tex, inputs lib*.tex)
-#   ref -- Language Reference (file ref.tex, inputs ref*.tex)
 #   ext -- Extending and Embedding (file ext.tex)
 #
+# The Reference Manual is now maintained as a FrameMaker document.
+# See the subdirectory ref; PostScript is included as ref/ref.ps.
+# (In the future, the Tutorial will also be converted to FrameMaker;
+# the other documents will be maintained in a text format such
+# as LaTeX or perhaps TIM.)
+#
 # The main target "make all" creates DVI and PostScript for these
 # four.  You can also do "make lib" (etc.) to process individual
 # documents.
@@ -74,20 +79,19 @@
 # Main target
 all:	all-ps
 
-all-dvi: tut.dvi lib.dvi ref.dvi ext.dvi
-all-ps:	tut.ps lib.ps ref.ps ext.ps
+all-dvi: tut.dvi lib.dvi ext.dvi
+all-ps:	tut.ps lib.ps ext.ps
 
 # Individual document fake targets
 tut:	tut.ps
 lib:	lib.ps
-ref:	ref.ps
 ext:	ext.ps
 
 # CWI Quarterly document fake target
 qua:	qua.ps
 
 # Dependencies
-tut.dvi lib.dvi ref.dvi ext.dvi: myformat.sty fix_hack
+tut.dvi lib.dvi ext.dvi: myformat.sty fix_hack
 
 # Tutorial document
 tut.dvi: tut.tex 
@@ -97,18 +101,6 @@
 tut.ps:	tut.dvi
 	$(DVIPS) tut >tut.ps
 
-# Reference document
-ref.dvi: ref.tex ref1.tex ref2.tex ref3.tex ref4.tex ref5.tex ref6.tex \
-						     ref7.tex ref8.tex 
-	touch ref.ind
-	$(LATEX) ref
-	./fix_hack ref.idx
-	$(MAKEINDEX) ref
-	$(LATEX) ref
-
-ref.ps:	ref.dvi
-	$(DVIPS) ref >ref.ps
-
 # LaTeX source files for the Python Library Reference
 LIBFILES = lib.tex \
     libintro.tex libobjs.tex libtypes.tex libexcs.tex libfuncs.tex \
@@ -216,11 +208,6 @@
 	@rm -rf python-tut
 	mv tut python-tut
 
-l2href: ref.dvi
-	$(L2H) $(L2HARGS) ref.tex
-	@rm -rf python-ref
-	mv ref python-ref
-
 l2hext: ext.dvi
 	$(L2H) $(L2HARGS) ext.tex
 	@rm -rf python-ext
diff --git a/Doc/ref.tex b/Doc/ref.tex
deleted file mode 100644
index e63fa7c..0000000
--- a/Doc/ref.tex
+++ /dev/null
@@ -1,68 +0,0 @@
-\documentstyle[twoside,11pt,myformat]{report}
-
-\title{Python Reference Manual}
-
-\input{boilerplate}
-
-% Tell \index to actually write the .idx file
-\makeindex
-
-\begin{document}
-
-\pagenumbering{roman}
-
-\maketitle
-
-\input{copyright}
-
-\begin{abstract}
-
-\noindent
-Python is a simple, yet powerful, interpreted programming language
-that bridges the gap between C and shell programming, and is thus
-ideally suited for ``throw-away programming'' and rapid prototyping.
-Its syntax is put together from constructs borrowed from a variety of
-other languages; most prominent are influences from ABC, C, Modula-3
-and Icon.
-
-The Python interpreter is easily extended with new functions and data
-types implemented in C.  Python is also suitable as an extension
-language for highly customizable C applications such as editors or
-window managers.
-
-Python is available for various operating systems, amongst which
-several flavors of {\UNIX} (including Linux), the Apple Macintosh O.S.,
-MS-DOS, MS-Windows 3.1, Windows NT, and OS/2.
-
-This reference manual describes the syntax and ``core semantics'' of
-the language.  It is terse, but attempts to be exact and complete.
-The semantics of non-essential built-in object types and of the
-built-in functions and modules are described in the {\em Python
-Library Reference}.  For an informal introduction to the language, see
-the {\em Python Tutorial}.
-
-\end{abstract}
-
-\pagebreak
-
-{
-\parskip = 0mm
-\tableofcontents
-}
-
-\pagebreak
-
-\pagenumbering{arabic}
-
-\include{ref1}		% Introduction
-\include{ref2}		% Lexical analysis
-\include{ref3}		% Data model
-\include{ref4}		% Execution model
-\include{ref5}		% Expressions and conditions
-\include{ref6}		% Simple statements
-\include{ref7}		% Compound statements
-\include{ref8}		% Top-level components
-
-\input{ref.ind}
-
-\end{document}
diff --git a/Doc/ref/ref.ps b/Doc/ref/ref.ps
new file mode 100644
index 0000000..198d968
--- /dev/null
+++ b/Doc/ref/ref.ps
@@ -0,0 +1,16373 @@
+%!PS-Adobe-3.0
+%%BoundingBox: (atend)
+%%Pages: (atend)
+%%PageOrder: (atend)
+%%DocumentFonts: (atend)
+%%Creator: Frame 5.0
+%%DocumentData: Clean7Bit
+%%EndComments
+%%BeginProlog
+%
+% Frame ps_prolog 5.0, for use with Frame 5.0 products
+% This ps_prolog file is Copyright (c) 1986-1995 Frame Technology
+% Corporation.  All rights reserved.  This ps_prolog file may be
+% freely copied and distributed in conjunction with documents created
+% using FrameMaker, FrameMaker/SGML and FrameViewer as long as this 
+% copyright notice is preserved.
+%
+% FrameMaker users specify the proper paper size for each print job in the
+% "Print" dialog's "Printer Paper Size" "Width" and "Height~ fields.  If the
+% printer that the PS file is sent to does not support the requested paper
+% size, or if there is no paper tray of the proper size currently installed, 
+% then the job will not be printed.  The following flag, if set to true, will
+% cause the job to print on the default paper in such cases.
+/FMAllowPaperSizeMismatch            false def
+%
+% Frame products normally print colors as their true color on a color printer
+% or as shades of gray, based on luminance, on a black-and white printer. The
+% following flag, if set to true, forces all non-white colors to print as pure
+% black. This has no effect on bitmap images.
+/FMPrintAllColorsAsBlack             false def
+%
+% Frame products can either set their own line screens or use a printer's 
+% default settings. Three flags below control this separately for no 
+% separations, spot separations and process separations. If a flag
+% is true, then the default printer settings will not be changed. If it is
+% false, Frame products will use their own settings from a table based on
+% the printer's resolution.
+/FMUseDefaultNoSeparationScreen      true  def
+/FMUseDefaultSpotSeparationScreen    true  def
+/FMUseDefaultProcessSeparationScreen false def
+%
+% For any given PostScript printer resolution, Frame products have two sets of 
+% screen angles and frequencies for printing process separations, which are 
+% recomended by Adobe. The following variable chooses the higher frequencies
+% when set to true or the lower frequencies when set to false. This is only
+% effective if the appropriate FMUseDefault...SeparationScreen flag is false.
+/FMUseHighFrequencyScreens true def
+%
+% The following is a set of predefined optimal frequencies and angles for various
+% common dpi settings. This is taken from "Advances in Color Separation Using
+% PostScript Software Technology," from Adobe Systems (3/13/89 P.N. LPS 0043)
+% and corrolated with information which is in various PPD (4.0) files.
+%
+% The "dpiranges" figure is the minimum dots per inch device resolution which
+% can support this setting. The "low" and "high" values are controlled by the
+% setting of the FMUseHighFrequencyScreens flag above. The "TDot" flags control
+% the use of the "Yellow Triple Dot" feature whereby the frequency id divided by
+% three, but the dot function is "trippled" giving a block of 3x3 dots per cell.
+%
+% PatFreq is a compromise pattern frequency for ps Level 2 printers which is close
+% to the ideal WYSIWYG pattern frequency of 9 repetitions/inch but does not beat
+% (too badly) against the screen frequencies of any separations for that DPI.
+/dpiranges   [  2540    2400    1693     1270    1200     635      600      0      ] def
+/CMLowFreqs  [ 100.402  94.8683 89.2289 100.402  94.8683  66.9349  63.2456 47.4342 ] def
+/YLowFreqs   [  95.25   90.0    84.65    95.25   90.0     70.5556  66.6667 50.0    ] def
+/KLowFreqs   [  89.8026 84.8528 79.8088  89.8026 84.8528  74.8355  70.7107 53.033  ] def
+/CLowAngles  [  71.5651 71.5651 71.5651 71.5651  71.5651  71.5651  71.5651 71.5651 ] def
+/MLowAngles  [  18.4349 18.4349 18.4349 18.4349  18.4349  18.4349  18.4349 18.4349 ] def
+/YLowTDot    [  true    true    false    true    true     false    false   false   ] def
+/CMHighFreqs [ 133.87  126.491 133.843  108.503 102.523  100.402   94.8683 63.2456 ] def
+/YHighFreqs  [ 127.0   120.0   126.975  115.455 109.091   95.25    90.0    60.0    ] def
+/KHighFreqs  [ 119.737 113.137 119.713  128.289 121.218   89.8026  84.8528 63.6395 ] def
+/CHighAngles [  71.5651 71.5651 71.5651  70.0169 70.0169  71.5651  71.5651 71.5651 ] def
+/MHighAngles [  18.4349 18.4349 18.4349  19.9831 19.9831  18.4349  18.4349 18.4349 ] def
+/YHighTDot   [  false   false   true     false   false    true     true    false   ] def
+/PatFreq     [	10.5833 10.0     9.4055  10.5833 10.0	  10.5833  10.0	   9.375   ] def
+%
+% PostScript Level 2 printers contain an "Accurate Screens" feature which can
+% improve process separation rendering at the expense of compute time. This 
+% flag is ignored by PostScript Level 1 printers.
+/FMUseAcccurateScreens true def
+%
+% The following PostScript procedure defines the spot function that Frame
+% products will use for process separations. You may un-comment-out one of
+% the alternative functions below, or use your own.
+%
+% Dot function
+/FMSpotFunction {abs exch abs 2 copy add 1 gt 
+		{1 sub dup mul exch 1 sub dup mul add 1 sub }
+		{dup mul exch dup mul add 1 exch sub }ifelse } def
+%
+% Line function
+% /FMSpotFunction { pop } def
+%
+% Elipse function
+% /FMSpotFunction { dup 5 mul 8 div mul exch dup mul exch add 
+%		sqrt 1 exch sub } def
+%
+%
+/FMversion (5.0) def 
+/fMLevel1 /languagelevel where {pop languagelevel} {1} ifelse 2 lt def
+/FMPColor
+	fMLevel1 {
+		false
+		/colorimage where {pop pop true} if
+	} {
+		true
+	} ifelse
+def
+/FrameDict 400 dict def 
+systemdict /errordict known not {/errordict 10 dict def
+		errordict /rangecheck {stop} put} if
+% The readline in PS 23.0 doesn't recognize cr's as nl's on AppleTalk
+FrameDict /tmprangecheck errordict /rangecheck get put 
+errordict /rangecheck {FrameDict /bug true put} put 
+FrameDict /bug false put 
+mark 
+% Some PS machines read past the CR, so keep the following 3 lines together!
+currentfile 5 string readline
+00
+0000000000
+cleartomark 
+errordict /rangecheck FrameDict /tmprangecheck get put 
+FrameDict /bug get { 
+	/readline {
+		/gstring exch def
+		/gfile exch def
+		/gindex 0 def
+		{
+			gfile read pop 
+			dup 10 eq {exit} if 
+			dup 13 eq {exit} if 
+			gstring exch gindex exch put 
+			/gindex gindex 1 add def 
+		} loop
+		pop 
+		gstring 0 gindex getinterval true 
+		} bind def
+	} if
+/FMshowpage /showpage load def
+/FMquit /quit load def
+/FMFAILURE { 
+	dup = flush 
+	FMshowpage 
+	/Helvetica findfont 12 scalefont setfont
+	72 200 moveto show
+	72 220 moveto show
+	FMshowpage 
+	FMquit 
+	} def 
+/FMVERSION {
+	FMversion ne {
+		(Frame product version does not match ps_prolog!  Check installation;)
+		(also check ~/fminit and ./fminit for old versions) FMFAILURE
+		} if
+	} def 
+/FMBADEPSF { 
+	(Adobe's PostScript Language Reference Manual, 2nd Edition, section H.2.4)
+	(says your EPS file is not valid, as it calls X              )
+	dup dup (X) search pop exch pop exch pop length 
+	5 -1 roll 
+	putinterval 
+	FMFAILURE
+	} def
+/fmConcatProcs
+	{
+	/proc2 exch cvlit def/proc1 exch cvlit def/newproc proc1 length proc2 length add array def
+	newproc 0 proc1 putinterval newproc proc1 length proc2 putinterval newproc cvx
+}def
+FrameDict begin [
+	/ALDsave
+	/FMdicttop
+	/FMoptop
+	/FMpointsize
+	/FMsaveobject
+	/b
+	/bitmapsave
+	/blut
+	/bpside
+	/bs
+	/bstring
+	/bwidth
+	/c
+	/cf
+	/cs
+	/cynu
+	/depth
+	/edown
+	/fh
+	/fillvals
+	/fw
+	/fx
+	/fy
+	/g
+	/gfile
+	/gindex
+	/grnt
+	/gryt
+	/gstring
+	/height
+	/hh
+	/i
+	/im
+	/indx
+	/is
+	/k
+	/kk
+	/landscape
+	/lb
+	/len
+	/llx
+	/lly
+	/m
+	/magu
+	/manualfeed
+	/n
+	/offbits
+	/onbits
+	/organgle
+	/orgbangle
+	/orgbfreq
+	/orgbproc
+	/orgbxfer
+	/orgfreq
+	/orggangle
+	/orggfreq
+	/orggproc
+	/orggxfer
+	/orgmatrix
+	/orgproc
+	/orgrangle
+	/orgrfreq
+	/orgrproc
+	/orgrxfer
+	/orgxfer
+	/pagesave
+	/paperheight
+	/papersizedict
+	/paperwidth
+	/pos
+	/pwid
+	/r
+	/rad
+	/redt
+	/sl
+	/str
+	/tran
+	/u
+	/urx
+	/ury
+	/val
+	/width
+	/width
+	/ws
+	/ww
+	/x
+	/x1
+	/x2
+	/xindex
+	/xpoint
+	/xscale
+	/xx
+	/y
+	/y1
+	/y2
+	/yelu
+	/yindex
+	/ypoint
+	/yscale
+	/yy
+] { 0 def } forall
+/FmBD {bind def} bind def
+systemdict /pdfmark known {
+	/fMAcrobat true def
+	
+	/FmPD /pdfmark load def
+	
+	
+	/FmPT /show load def
+	
+	
+	currentdistillerparams /CoreDistVersion get 2000 ge {
+	
+		
+		/FmPD2 /pdfmark load def
+		
+		
+		
+		
+		
+		/FmPA { mark exch /Dest exch 5 3 roll 
+				/View [ /XYZ null 6 -2 roll FmDC exch pop null] /DEST FmPD 
+		}FmBD
+	} {
+		
+		/FmPD2 /cleartomark load def
+		/FmPA {pop pop pop}FmBD
+	} ifelse
+} {
+	
+	/fMAcrobat false def
+	/FmPD /cleartomark load def
+	/FmPD2 /cleartomark load def
+	/FmPT /pop load def
+	/FmPA {pop pop pop}FmBD
+} ifelse
+/FmDC {
+	transform fMDefaultMatrix itransform cvi exch cvi exch
+}FmBD
+/FmBx {
+	dup 3 index lt {3 1 roll exch} if 
+	1 index 4 index lt {4 -1 roll 3 1 roll exch 4 1 roll} if
+}FmBD
+/FMnone 0 def
+/FMcyan 1 def
+/FMmagenta 2 def
+/FMyellow 3 def
+/FMblack 4 def
+/FMcustom 5 def
+/fMNegative false def 
+/FrameSepIs FMnone def 
+/FrameSepBlack 0 def
+/FrameSepYellow 0 def
+/FrameSepMagenta 0 def
+/FrameSepCyan 0 def
+/FrameSepRed 1 def
+/FrameSepGreen 1 def
+/FrameSepBlue 1 def
+/FrameCurGray 1 def
+/FrameCurPat null def
+/FrameCurColors [ 0 0 0 1 0 0 0 ] def 
+/FrameColorEpsilon .001 def	
+/eqepsilon {		
+	sub dup 0 lt {neg} if
+	FrameColorEpsilon le
+} bind def
+/FrameCmpColorsCMYK { 
+	2 copy 0 get exch 0 get eqepsilon {
+		2 copy 1 get exch 1 get eqepsilon {
+			2 copy 2 get exch 2 get eqepsilon {
+				3 get exch 3 get eqepsilon
+			} {pop pop false} ifelse
+		}{pop pop false} ifelse
+	} {pop pop false} ifelse
+} bind def
+/FrameCmpColorsRGB { 
+	2 copy 4 get exch 0 get eqepsilon {
+		2 copy 5 get exch 1 get eqepsilon {
+			6 get exch 2 get eqepsilon
+		}{pop pop false} ifelse
+	} {pop pop false} ifelse
+} bind def
+/RGBtoCMYK { 
+	1 exch sub 
+	3 1 roll 
+	1 exch sub 
+	3 1 roll 
+	1 exch sub 
+	3 1 roll 
+	3 copy 
+	2 copy 
+	le { pop } { exch pop } ifelse 
+	2 copy 
+	le { pop } { exch pop } ifelse 
+	dup dup dup 
+	6 1 roll 
+	4 1 roll 
+	7 1 roll 
+	sub 
+	6 1 roll 
+	sub 
+	5 1 roll 
+	sub 
+	4 1 roll 
+} bind def
+/CMYKtoRGB { 
+	dup dup 4 -1 roll add 						  
+	5 1 roll 3 -1 roll add 						  
+	4 1 roll add 								  
+	1 exch sub dup 0 lt {pop 0} if 3 1 roll 	  
+	1 exch sub dup 0 lt {pop 0} if exch 	      
+	1 exch sub dup 0 lt {pop 0} if exch	  		  
+} bind def
+/FrameSepInit {
+	1.0 RealSetgray
+} bind def
+/FrameSetSepColor { 
+	/FrameSepBlue exch def
+	/FrameSepGreen exch def
+	/FrameSepRed exch def
+	/FrameSepBlack exch def
+	/FrameSepYellow exch def
+	/FrameSepMagenta exch def
+	/FrameSepCyan exch def
+	/FrameSepIs FMcustom def
+	setCurrentScreen	
+} bind def
+/FrameSetCyan {
+	/FrameSepBlue 1.0 def
+	/FrameSepGreen 1.0 def
+	/FrameSepRed 0.0 def
+	/FrameSepBlack 0.0 def
+	/FrameSepYellow 0.0 def
+	/FrameSepMagenta 0.0 def
+	/FrameSepCyan 1.0 def
+	/FrameSepIs FMcyan def
+	setCurrentScreen	
+} bind def
+ 
+/FrameSetMagenta {
+	/FrameSepBlue 1.0 def
+	/FrameSepGreen 0.0 def
+	/FrameSepRed 1.0 def
+	/FrameSepBlack 0.0 def
+	/FrameSepYellow 0.0 def
+	/FrameSepMagenta 1.0 def
+	/FrameSepCyan 0.0 def
+	/FrameSepIs FMmagenta def
+	setCurrentScreen
+} bind def
+ 
+/FrameSetYellow {
+	/FrameSepBlue 0.0 def
+	/FrameSepGreen 1.0 def
+	/FrameSepRed 1.0 def
+	/FrameSepBlack 0.0 def
+	/FrameSepYellow 1.0 def
+	/FrameSepMagenta 0.0 def
+	/FrameSepCyan 0.0 def
+	/FrameSepIs FMyellow def
+	setCurrentScreen
+} bind def
+ 
+/FrameSetBlack {
+	/FrameSepBlue 0.0 def
+	/FrameSepGreen 0.0 def
+	/FrameSepRed 0.0 def
+	/FrameSepBlack 1.0 def
+	/FrameSepYellow 0.0 def
+	/FrameSepMagenta 0.0 def
+	/FrameSepCyan 0.0 def
+	/FrameSepIs FMblack def
+	setCurrentScreen
+} bind def
+ 
+/FrameNoSep { 
+	/FrameSepIs FMnone def
+	setCurrentScreen
+} bind def
+/FrameSetSepColors { 
+	FrameDict begin
+	[ exch 1 add 1 roll ]
+	/FrameSepColors  
+	exch def end
+	} bind def
+/FrameColorInSepListCMYK { 
+	FrameSepColors {  
+       		exch dup 3 -1 roll 
+       		FrameCmpColorsCMYK 
+       		{ pop true exit } if
+    	} forall 
+	dup true ne {pop false} if
+	} bind def
+/FrameColorInSepListRGB { 
+	FrameSepColors {  
+       		exch dup 3 -1 roll 
+       		FrameCmpColorsRGB 
+       		{ pop true exit } if
+    	} forall 
+	dup true ne {pop false} if
+	} bind def
+/RealSetgray /setgray load def
+/RealSetrgbcolor /setrgbcolor load def
+/RealSethsbcolor /sethsbcolor load def
+end 
+/setgray { 
+	FrameDict begin
+	FrameSepIs FMnone eq
+		{ RealSetgray } 
+		{ 
+		FrameSepIs FMblack eq 
+			{ RealSetgray } 
+			{ FrameSepIs FMcustom eq 
+			  FrameSepRed 0 eq and
+			  FrameSepGreen 0 eq and
+			  FrameSepBlue 0 eq and {
+			  	RealSetgray
+			  } {
+				1 RealSetgray pop 
+			  } ifelse
+			} ifelse
+		} ifelse
+	end
+} bind def
+/setrgbcolor { 
+	FrameDict begin
+	FrameSepIs FMnone eq
+	{  RealSetrgbcolor }
+	{
+		3 copy [ 4 1 roll ] 
+		FrameColorInSepListRGB
+		{
+				FrameSepBlue eq exch 
+			 	FrameSepGreen eq and exch 
+			 	FrameSepRed eq and
+			 	{ 0 } { 1 } ifelse
+		}
+		{
+			FMPColor {
+				RealSetrgbcolor
+				currentcmykcolor
+			} {
+				RGBtoCMYK
+			} ifelse
+			FrameSepIs FMblack eq
+			{1.0 exch sub 4 1 roll pop pop pop} {
+			FrameSepIs FMyellow eq
+			{pop 1.0 exch sub 3 1 roll pop pop} {
+			FrameSepIs FMmagenta eq
+			{pop pop 1.0 exch sub exch pop } {
+			FrameSepIs FMcyan eq
+			{pop pop pop 1.0 exch sub } 
+			{pop pop pop pop 1} ifelse } ifelse } ifelse } ifelse 
+		} ifelse
+		RealSetgray
+	} 
+	ifelse
+	end
+} bind def
+/sethsbcolor {
+	FrameDict begin
+	FrameSepIs FMnone eq 
+	{ RealSethsbcolor } 
+	{
+		RealSethsbcolor 
+		currentrgbcolor  
+		setrgbcolor 
+	} 
+	ifelse
+	end
+} bind def
+FrameDict begin
+/setcmykcolor where {
+	pop /RealSetcmykcolor /setcmykcolor load def
+} {
+	/RealSetcmykcolor {
+		4 1 roll
+		3 { 3 index add 0 max 1 min 1 exch sub 3 1 roll} repeat 
+		RealSetrgbcolor pop
+	} bind def
+} ifelse
+userdict /setcmykcolor { 
+		FrameDict begin
+		FrameSepIs FMnone eq
+		{ RealSetcmykcolor } 
+		{
+			4 copy [ 5 1 roll ]
+			FrameColorInSepListCMYK
+			{
+				FrameSepBlack eq exch 
+				FrameSepYellow eq and exch 
+				FrameSepMagenta eq and exch 
+				FrameSepCyan eq and 
+				{ 0 } { 1 } ifelse
+			}
+			{
+				FrameSepIs FMblack eq
+				{1.0 exch sub 4 1 roll pop pop pop} {
+				FrameSepIs FMyellow eq
+				{pop 1.0 exch sub 3 1 roll pop pop} {
+				FrameSepIs FMmagenta eq
+				{pop pop 1.0 exch sub exch pop } {
+				FrameSepIs FMcyan eq
+				{pop pop pop 1.0 exch sub } 
+				{pop pop pop pop 1} ifelse } ifelse } ifelse } ifelse 
+			} ifelse
+			RealSetgray
+		}
+		ifelse
+		end
+	} bind put
+fMLevel1 { 
+	
+	
+	
+	/patScreenDict 7 dict dup begin
+		<0f1e3c78f0e1c387> [ 45  { pop } {exch pop} 		.5   2 sqrt] FmBD
+		<0f87c3e1f0783c1e> [ 135 { pop } {exch pop}			.5   2 sqrt] FmBD
+		<cccccccccccccccc> [ 0   { pop } dup				.5   2	   ] FmBD
+		<ffff0000ffff0000> [ 90  { pop } dup				.5   2	   ] FmBD
+		<8142241818244281> [ 45  { 2 copy lt {exch} if pop}	dup .75  2 sqrt] FmBD
+		<03060c183060c081> [ 45  { pop } {exch pop}			.875 2 sqrt] FmBD
+		<8040201008040201> [ 135 { pop } {exch pop}			.875 2 sqrt] FmBD
+	end def
+} { 
+	
+	/patProcDict 5 dict dup begin
+		<0f1e3c78f0e1c387> { 3 setlinewidth -1 -1 moveto 9 9 lineto stroke 
+											4 -4 moveto 12 4 lineto stroke
+											-4 4 moveto 4 12 lineto stroke} bind def
+		<0f87c3e1f0783c1e> { 3 setlinewidth -1 9 moveto 9 -1 lineto stroke 
+											-4 4 moveto 4 -4 lineto stroke
+											4 12 moveto 12 4 lineto stroke} bind def
+		<8142241818244281> { 1 setlinewidth -1 9 moveto 9 -1 lineto stroke
+											-1 -1 moveto 9 9 lineto stroke } bind def
+		<03060c183060c081> { 1 setlinewidth -1 -1 moveto 9 9 lineto stroke 
+											4 -4 moveto 12 4 lineto stroke
+											-4 4 moveto 4 12 lineto stroke} bind def
+		<8040201008040201> { 1 setlinewidth -1 9 moveto 9 -1 lineto stroke 
+											-4 4 moveto 4 -4 lineto stroke
+											4 12 moveto 12 4 lineto stroke} bind def
+	end def
+	/patDict 15 dict dup begin
+		/PatternType 1 def		
+		/PaintType 2 def		
+		/TilingType 3 def		
+		/BBox [ 0 0 8 8 ] def 	
+		/XStep 8 def			
+		/YStep 8 def			
+		/PaintProc {
+			begin
+			patProcDict bstring known {
+				patProcDict bstring get exec
+			} {
+				8 8 true [1 0 0 -1 0 8] bstring imagemask
+			} ifelse
+			end
+		} bind def
+	end def
+} ifelse
+/combineColor {
+    FrameSepIs FMnone eq
+	{
+		graymode fMLevel1 or not {
+			
+			[/Pattern [/DeviceCMYK]] setcolorspace
+			FrameCurColors 0 4 getinterval aload pop FrameCurPat setcolor
+		} {
+			FrameCurColors 3 get 1.0 ge {
+				FrameCurGray RealSetgray
+			} {
+				fMAcrobat not FMPColor graymode and and {
+					0 1 3 { 
+						FrameCurColors exch get
+						1 FrameCurGray sub mul
+					} for
+					RealSetcmykcolor
+				} {
+					4 1 6 {
+						FrameCurColors exch get
+						graymode {
+							1 exch sub 1 FrameCurGray sub mul 1 exch sub
+						} {
+							1.0 lt {FrameCurGray} {1} ifelse
+						} ifelse
+					} for
+					RealSetrgbcolor
+				} ifelse
+			} ifelse
+		} ifelse
+	} { 
+		FrameCurColors 0 4 getinterval aload
+		FrameColorInSepListCMYK {
+			FrameSepBlack eq exch 
+			FrameSepYellow eq and exch 
+			FrameSepMagenta eq and exch 
+			FrameSepCyan eq and
+			FrameSepIs FMcustom eq and
+			{ FrameCurGray } { 1 } ifelse
+		} {
+			FrameSepIs FMblack eq
+			{FrameCurGray 1.0 exch sub mul 1.0 exch sub 4 1 roll pop pop pop} {
+			FrameSepIs FMyellow eq
+			{pop FrameCurGray 1.0 exch sub mul 1.0 exch sub 3 1 roll pop pop} {
+			FrameSepIs FMmagenta eq
+			{pop pop FrameCurGray 1.0 exch sub mul 1.0 exch sub exch pop } {
+			FrameSepIs FMcyan eq
+			{pop pop pop FrameCurGray 1.0 exch sub mul 1.0 exch sub } 
+			{pop pop pop pop 1} ifelse } ifelse } ifelse } ifelse 
+		} ifelse
+		graymode fMLevel1 or not {
+			
+			[/Pattern [/DeviceGray]] setcolorspace
+			FrameCurPat setcolor
+		} { 
+			graymode not fMLevel1 and {
+				
+				dup 1 lt {pop FrameCurGray} if
+			} if
+			RealSetgray
+		} ifelse
+	} ifelse
+} bind def
+/savematrix {
+	orgmatrix currentmatrix pop
+	} bind def
+/restorematrix {
+	orgmatrix setmatrix
+	} bind def
+/fMDefaultMatrix matrix defaultmatrix def
+/fMatrix2 matrix def
+/dpi    72 0 fMDefaultMatrix dtransform
+    dup mul exch   dup mul add   sqrt def
+	
+/freq dpi dup 72 div round dup 0 eq {pop 1} if 8 mul div def
+/sangle 1 0 fMDefaultMatrix dtransform exch atan def
+	sangle fMatrix2 rotate 
+	fMDefaultMatrix fMatrix2 concatmatrix 
+	dup 0 get /sflipx exch def
+	    3 get /sflipy exch def
+/screenIndex {
+	0 1 dpiranges length 1 sub { dup dpiranges exch get 1 sub dpi le {exit} {pop} ifelse } for
+} bind def
+/getCyanScreen {
+	FMUseHighFrequencyScreens { CHighAngles CMHighFreqs} {CLowAngles CMLowFreqs} ifelse
+		screenIndex dup 3 1 roll get 3 1 roll get /FMSpotFunction load
+} bind def
+/getMagentaScreen {
+	FMUseHighFrequencyScreens { MHighAngles CMHighFreqs } {MLowAngles CMLowFreqs} ifelse
+		screenIndex dup 3 1 roll get 3 1 roll get /FMSpotFunction load
+} bind def
+/getYellowScreen {
+	FMUseHighFrequencyScreens { YHighTDot YHighFreqs} { YLowTDot YLowFreqs } ifelse
+		screenIndex dup 3 1 roll get 3 1 roll get { 3 div
+			{2 { 1 add 2 div 3 mul dup floor sub 2 mul 1 sub exch} repeat
+			FMSpotFunction } } {/FMSpotFunction load } ifelse
+			0.0 exch
+} bind def
+/getBlackScreen  {
+	FMUseHighFrequencyScreens { KHighFreqs } { KLowFreqs } ifelse
+		screenIndex get 45.0 /FMSpotFunction load 
+} bind def
+/getSpotScreen {
+	getBlackScreen
+} bind def
+/getCompositeScreen {
+	getBlackScreen
+} bind def
+/FMSetScreen 
+	fMLevel1 { /setscreen load 
+	}{ {
+		8 dict begin
+		/HalftoneType 1 def
+		/SpotFunction exch def
+		/Angle exch def
+		/Frequency exch def
+		/AccurateScreens FMUseAcccurateScreens def
+		currentdict end sethalftone
+	} bind } ifelse
+def
+/setDefaultScreen {
+	FMPColor {
+		orgrxfer cvx orggxfer cvx orgbxfer cvx orgxfer cvx setcolortransfer
+	}
+	{
+		orgxfer cvx settransfer
+	} ifelse
+	orgfreq organgle orgproc cvx setscreen
+} bind def
+/setCurrentScreen {
+	FrameSepIs FMnone eq {
+		FMUseDefaultNoSeparationScreen {
+			setDefaultScreen
+		} {
+			getCompositeScreen FMSetScreen
+		} ifelse
+	} {
+		FrameSepIs FMcustom eq {
+			FMUseDefaultSpotSeparationScreen {
+				setDefaultScreen
+			} {
+				getSpotScreen FMSetScreen
+			} ifelse
+		} {
+			FMUseDefaultProcessSeparationScreen {
+				setDefaultScreen
+			} {
+				FrameSepIs FMcyan eq {
+					getCyanScreen FMSetScreen
+				} {
+					FrameSepIs FMmagenta eq {
+						getMagentaScreen FMSetScreen
+					} {
+						FrameSepIs FMyellow eq {
+							getYellowScreen FMSetScreen
+						} {
+							getBlackScreen FMSetScreen
+						} ifelse
+					} ifelse
+				} ifelse
+			} ifelse
+		} ifelse
+	} ifelse 
+} bind def
+end
+	
+/FMDOCUMENT { 
+	array /FMfonts exch def 
+	/#copies exch def
+	FrameDict begin
+	0 ne /manualfeed exch def
+	/paperheight exch def
+	/paperwidth exch def
+	0 ne /fMNegative exch def 
+	0 ne /edown exch def 
+	/yscale exch def
+	/xscale exch def
+	fMLevel1 {
+		manualfeed {setmanualfeed} if
+		/FMdicttop countdictstack 1 add def 
+		/FMoptop count def 
+		setpapername 
+		manualfeed {true} {papersize} ifelse 
+		{manualpapersize} {false} ifelse 
+		{desperatepapersize} {false} ifelse 
+		{papersizefailure} if
+		count -1 FMoptop {pop pop} for
+		countdictstack -1 FMdicttop {pop end} for 
+		}
+		{2 dict
+		 dup /PageSize [paperwidth paperheight] put
+		 manualfeed {dup /ManualFeed manualfeed put} if
+		 {setpagedevice} stopped {papersizefailure} if
+		}
+	ifelse 
+	
+	FMPColor {
+		currentcolorscreen
+			cvlit /orgproc exch def
+				  /organgle exch def 
+				  /orgfreq exch def
+			cvlit /orgbproc exch def
+				  /orgbangle exch def 
+				  /orgbfreq exch def
+			cvlit /orggproc exch def
+				  /orggangle exch def 
+				  /orggfreq exch def
+			cvlit /orgrproc exch def
+				  /orgrangle exch def 
+				  /orgrfreq exch def
+			currentcolortransfer 
+			fMNegative {
+				1 1 4 { 
+					pop { 1 exch sub } fmConcatProcs 4 1 roll
+				} for
+				4 copy
+				setcolortransfer
+			} if
+			cvlit /orgxfer exch def
+			cvlit /orgbxfer exch def
+			cvlit /orggxfer exch def
+			cvlit /orgrxfer exch def
+	} {
+		currentscreen 
+			cvlit /orgproc exch def
+				  /organgle exch def 
+				  /orgfreq exch def
+				  
+		currenttransfer 
+		fMNegative {
+			{ 1 exch sub } fmConcatProcs
+			dup settransfer
+		} if 
+		cvlit /orgxfer exch def
+	} ifelse
+	end 
+} def 
+/FMBEGINPAGE { 
+	FrameDict begin 
+	/pagesave save def
+	3.86 setmiterlimit
+	/landscape exch 0 ne def
+	landscape { 
+		90 rotate 0 exch dup /pwid exch def neg translate pop 
+	}{
+		pop /pwid exch def
+	} ifelse
+	edown { [-1 0 0 1 pwid 0] concat } if
+	0 0 moveto paperwidth 0 lineto paperwidth paperheight lineto 
+	0 paperheight lineto 0 0 lineto 1 setgray fill
+	xscale yscale scale
+	/orgmatrix matrix def
+	gsave 
+} def 
+/FMENDPAGE {
+	grestore 
+	pagesave restore
+	end 
+	showpage
+	} def 
+/FMFONTDEFINE { 
+	FrameDict begin
+	findfont 
+	ReEncode 
+	1 index exch 
+	definefont 
+	FMfonts 3 1 roll 
+	put
+	end 
+	} def 
+/FMFILLS {
+	FrameDict begin dup
+	array /fillvals exch def
+	dict /patCache exch def
+	end 
+	} def 
+/FMFILL {
+	FrameDict begin
+	 fillvals 3 1 roll put
+	end 
+	} def 
+/FMNORMALIZEGRAPHICS { 
+	newpath
+	1 setlinewidth
+	0 setlinecap
+	0 0 0 sethsbcolor
+	0 setgray 
+	} bind def
+/FMBEGINEPSF { 
+	end 
+	/FMEPSF save def 
+	/showpage {} def 
+% See Adobe's "PostScript Language Reference Manual, 2nd Edition", page 714.
+% "...the following operators MUST NOT be used in an EPS file:" (emphasis ours)
+	/banddevice {(banddevice) FMBADEPSF} def
+	/clear {(clear) FMBADEPSF} def
+	/cleardictstack {(cleardictstack) FMBADEPSF} def 
+	/copypage {(copypage) FMBADEPSF} def
+	/erasepage {(erasepage) FMBADEPSF} def
+	/exitserver {(exitserver) FMBADEPSF} def
+	/framedevice {(framedevice) FMBADEPSF} def
+	/grestoreall {(grestoreall) FMBADEPSF} def
+	/initclip {(initclip) FMBADEPSF} def
+	/initgraphics {(initgraphics) FMBADEPSF} def
+	/quit {(quit) FMBADEPSF} def
+	/renderbands {(renderbands) FMBADEPSF} def
+	/setglobal {(setglobal) FMBADEPSF} def
+	/setpagedevice {(setpagedevice) FMBADEPSF} def
+	/setshared {(setshared) FMBADEPSF} def
+	/startjob {(startjob) FMBADEPSF} def
+	/lettertray {(lettertray) FMBADEPSF} def
+	/letter {(letter) FMBADEPSF} def
+	/lettersmall {(lettersmall) FMBADEPSF} def
+	/11x17tray {(11x17tray) FMBADEPSF} def
+	/11x17 {(11x17) FMBADEPSF} def
+	/ledgertray {(ledgertray) FMBADEPSF} def
+	/ledger {(ledger) FMBADEPSF} def
+	/legaltray {(legaltray) FMBADEPSF} def
+	/legal {(legal) FMBADEPSF} def
+	/statementtray {(statementtray) FMBADEPSF} def
+	/statement {(statement) FMBADEPSF} def
+	/executivetray {(executivetray) FMBADEPSF} def
+	/executive {(executive) FMBADEPSF} def
+	/a3tray {(a3tray) FMBADEPSF} def
+	/a3 {(a3) FMBADEPSF} def
+	/a4tray {(a4tray) FMBADEPSF} def
+	/a4 {(a4) FMBADEPSF} def
+	/a4small {(a4small) FMBADEPSF} def
+	/b4tray {(b4tray) FMBADEPSF} def
+	/b4 {(b4) FMBADEPSF} def
+	/b5tray {(b5tray) FMBADEPSF} def
+	/b5 {(b5) FMBADEPSF} def
+	FMNORMALIZEGRAPHICS 
+	[/fy /fx /fh /fw /ury /urx /lly /llx] {exch def} forall 
+	fx fw 2 div add fy fh 2 div add  translate
+	rotate
+	fw 2 div neg fh 2 div neg translate
+	fw urx llx sub div fh ury lly sub div scale 
+	llx neg lly neg translate 
+	/FMdicttop countdictstack 1 add def 
+	/FMoptop count def 
+	} bind def
+/FMENDEPSF {
+	count -1 FMoptop {pop pop} for 
+	countdictstack -1 FMdicttop {pop end} for 
+	FMEPSF restore
+	FrameDict begin 
+	} bind def
+FrameDict begin 
+/setmanualfeed {
+%%BeginFeature *ManualFeed True
+	 statusdict /manualfeed true put
+%%EndFeature
+	} bind def
+/max {2 copy lt {exch} if pop} bind def
+/min {2 copy gt {exch} if pop} bind def
+/inch {72 mul} def
+/pagedimen { 
+	paperheight sub abs 16 lt exch 
+	paperwidth sub abs 16 lt and
+	{/papername exch def} {pop} ifelse
+	} bind def
+/setpapername { 
+	/papersizedict 14 dict def 
+	papersizedict begin
+	/papername /unknown def 
+		/Letter 8.5 inch 11.0 inch pagedimen
+		/LetterSmall 7.68 inch 10.16 inch pagedimen
+		/Tabloid 11.0 inch 17.0 inch pagedimen
+		/Ledger 17.0 inch 11.0 inch pagedimen
+		/Legal 8.5 inch 14.0 inch pagedimen
+		/Statement 5.5 inch 8.5 inch pagedimen
+		/Executive 7.5 inch 10.0 inch pagedimen
+		/A3 11.69 inch 16.5 inch pagedimen
+		/A4 8.26 inch 11.69 inch pagedimen
+		/A4Small 7.47 inch 10.85 inch pagedimen
+		/B4 10.125 inch 14.33 inch pagedimen
+		/B5 7.16 inch 10.125 inch pagedimen
+	end
+	} bind def
+/papersize {
+	papersizedict begin
+		/Letter {lettertray letter} def
+		/LetterSmall {lettertray lettersmall} def
+		/Tabloid {11x17tray 11x17} def
+		/Ledger {ledgertray ledger} def
+		/Legal {legaltray legal} def
+		/Statement {statementtray statement} def
+		/Executive {executivetray executive} def
+		/A3 {a3tray a3} def
+		/A4 {a4tray a4} def
+		/A4Small {a4tray a4small} def
+		/B4 {b4tray b4} def
+		/B5 {b5tray b5} def
+		/unknown {unknown} def
+	papersizedict dup papername known {papername} {/unknown} ifelse get
+	end
+	statusdict begin stopped end 
+	} bind def
+/manualpapersize {
+	papersizedict begin
+		/Letter {letter} def
+		/LetterSmall {lettersmall} def
+		/Tabloid {11x17} def
+		/Ledger {ledger} def
+		/Legal {legal} def
+		/Statement {statement} def
+		/Executive {executive} def
+		/A3 {a3} def
+		/A4 {a4} def
+		/A4Small {a4small} def
+		/B4 {b4} def
+		/B5 {b5} def
+		/unknown {unknown} def
+	papersizedict dup papername known {papername} {/unknown} ifelse get
+	end
+	stopped 
+	} bind def
+/desperatepapersize {
+	statusdict /setpageparams known
+		{
+		paperwidth paperheight 0 1 
+		statusdict begin
+		{setpageparams} stopped 
+		end
+		} {true} ifelse 
+	} bind def
+/papersizefailure {
+	FMAllowPaperSizeMismatch not
+		{
+(The requested paper size is not available in any currently-installed tray)
+(Edit the PS file to "FMAllowPaperSizeMismatch true" to use default tray)
+		 FMFAILURE } if
+	} def
+/DiacriticEncoding [
+/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
+/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
+/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
+/.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
+/.notdef /.notdef /.notdef /.notdef /space /exclam /quotedbl
+/numbersign /dollar /percent /ampersand /quotesingle /parenleft
+/parenright /asterisk /plus /comma /hyphen /period /slash /zero /one
+/two /three /four /five /six /seven /eight /nine /colon /semicolon
+/less /equal /greater /question /at /A /B /C /D /E /F /G /H /I /J /K
+/L /M /N /O /P /Q /R /S /T /U /V /W /X /Y /Z /bracketleft /backslash
+/bracketright /asciicircum /underscore /grave /a /b /c /d /e /f /g /h
+/i /j /k /l /m /n /o /p /q /r /s /t /u /v /w /x /y /z /braceleft /bar
+/braceright /asciitilde /.notdef /Adieresis /Aring /Ccedilla /Eacute
+/Ntilde /Odieresis /Udieresis /aacute /agrave /acircumflex /adieresis
+/atilde /aring /ccedilla /eacute /egrave /ecircumflex /edieresis
+/iacute /igrave /icircumflex /idieresis /ntilde /oacute /ograve
+/ocircumflex /odieresis /otilde /uacute /ugrave /ucircumflex
+/udieresis /dagger /.notdef /cent /sterling /section /bullet
+/paragraph /germandbls /registered /copyright /trademark /acute
+/dieresis /.notdef /AE /Oslash /.notdef /.notdef /.notdef /.notdef
+/yen /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
+/ordfeminine /ordmasculine /.notdef /ae /oslash /questiondown
+/exclamdown /logicalnot /.notdef /florin /.notdef /.notdef
+/guillemotleft /guillemotright /ellipsis /.notdef /Agrave /Atilde
+/Otilde /OE /oe /endash /emdash /quotedblleft /quotedblright
+/quoteleft /quoteright /.notdef /.notdef /ydieresis /Ydieresis
+/fraction /currency /guilsinglleft /guilsinglright /fi /fl /daggerdbl
+/periodcentered /quotesinglbase /quotedblbase /perthousand
+/Acircumflex /Ecircumflex /Aacute /Edieresis /Egrave /Iacute
+/Icircumflex /Idieresis /Igrave /Oacute /Ocircumflex /.notdef /Ograve
+/Uacute /Ucircumflex /Ugrave /dotlessi /circumflex /tilde /macron
+/breve /dotaccent /ring /cedilla /hungarumlaut /ogonek /caron
+] def
+/ReEncode { 
+	dup 
+	length 
+	dict begin 
+	{
+	1 index /FID ne 
+		{def} 
+		{pop pop} ifelse 
+	} forall 
+	0 eq {/Encoding DiacriticEncoding def} if 
+	currentdict 
+	end 
+	} bind def
+FMPColor 
+	
+	{
+	/BEGINBITMAPCOLOR { 
+		BITMAPCOLOR} def
+	/BEGINBITMAPCOLORc { 
+		BITMAPCOLORc} def
+	/BEGINBITMAPTRUECOLOR { 
+		BITMAPTRUECOLOR } def
+	/BEGINBITMAPTRUECOLORc { 
+		BITMAPTRUECOLORc } def
+	/BEGINBITMAPCMYK { 
+		BITMAPCMYK } def
+	/BEGINBITMAPCMYKc { 
+		BITMAPCMYKc } def
+	}
+	
+	{
+	/BEGINBITMAPCOLOR { 
+		BITMAPGRAY} def
+	/BEGINBITMAPCOLORc { 
+		BITMAPGRAYc} def
+	/BEGINBITMAPTRUECOLOR { 
+		BITMAPTRUEGRAY } def
+	/BEGINBITMAPTRUECOLORc { 
+		BITMAPTRUEGRAYc } def
+	/BEGINBITMAPCMYK { 
+		BITMAPCMYKGRAY } def
+	/BEGINBITMAPCMYKc { 
+		BITMAPCMYKGRAYc } def
+	}
+ifelse
+/K { 
+	FMPrintAllColorsAsBlack {
+		dup 1 eq 2 index 1 eq and 3 index 1 eq and not
+			{7 {pop} repeat 0 0 0 1 0 0 0} if
+	} if 
+	FrameCurColors astore 
+	pop combineColor
+} bind def
+/graymode true def
+fMLevel1 {
+	/fmGetFlip {
+		fMatrix2 exch get mul 0 lt { -1 } { 1 } ifelse
+	} FmBD
+} if
+/setPatternMode {
+	fMLevel1 {
+		2 index patScreenDict exch known {
+			pop pop
+			patScreenDict exch get aload pop 
+			freq 								
+			mul									
+			5 2 roll							
+			fMatrix2 currentmatrix 1 get 0 ne {
+				3 -1 roll 90 add 3 1 roll 		
+				sflipx 1 fmGetFlip sflipy 2 fmGetFlip neg mul
+			} {  								
+				sflipx 0 fmGetFlip sflipy 3 fmGetFlip mul 
+			} ifelse
+			0 lt {exch pop} {pop} ifelse 		
+			fMNegative { 
+				{neg} fmConcatProcs 			
+			} if
+			bind
+			
+			
+			
+			systemdict /setscreen get exec		
+			/FrameCurGray exch def
+		} {
+			/bwidth  exch def
+			/bpside  exch def
+			/bstring exch def
+			/onbits 0 def  /offbits 0 def
+			freq sangle landscape {90 add} if 
+				{/ypoint exch def
+				 /xpoint exch def
+				 /xindex xpoint 1 add 2 div bpside mul cvi def
+				 /yindex ypoint 1 add 2 div bpside mul cvi def
+				 bstring yindex bwidth mul xindex 8 idiv add get
+				 1 7 xindex 8 mod sub bitshift and 0 ne fMNegative {not} if
+				 {/onbits  onbits  1 add def 1}
+				 {/offbits offbits 1 add def 0}
+				 ifelse
+				}
+				setscreen
+			offbits offbits onbits add div fMNegative {1.0 exch sub} if
+			/FrameCurGray exch def
+		} ifelse
+	} { 
+		pop pop
+		dup patCache exch known {
+			patCache exch get
+		} { 
+			dup
+			patDict /bstring 3 -1 roll put
+			patDict 
+			9 PatFreq screenIndex get div dup matrix scale
+			makepattern
+			dup 
+			patCache 4 -1 roll 3 -1 roll put
+		} ifelse
+		/FrameCurGray 0 def
+		/FrameCurPat exch def
+	} ifelse
+	/graymode false def
+	combineColor
+} bind def
+/setGrayScaleMode {
+	graymode not {
+		/graymode true def
+		fMLevel1 {
+			setCurrentScreen
+		} if
+	} if
+	/FrameCurGray exch def
+	combineColor
+} bind def
+/normalize {
+	transform round exch round exch itransform
+	} bind def
+/dnormalize {
+	dtransform round exch round exch idtransform
+	} bind def
+/lnormalize { 
+	0 dtransform exch cvi 2 idiv 2 mul 1 add exch idtransform pop
+	} bind def
+/H { 
+	lnormalize setlinewidth
+	} bind def
+/Z {
+	setlinecap
+	} bind def
+	
+/PFill {
+	graymode fMLevel1 or not {
+		gsave 1 setgray eofill grestore
+	} if
+} bind def
+/PStroke {
+	graymode fMLevel1 or not {
+		gsave 1 setgray stroke grestore
+	} if
+	stroke
+} bind def
+/X { 
+	fillvals exch get
+	dup type /stringtype eq
+	{8 1 setPatternMode} 
+	{setGrayScaleMode}
+	ifelse
+	} bind def
+/V { 
+	PFill gsave eofill grestore
+	} bind def
+/Vclip {
+	clip
+	} bind def
+/Vstrk {
+	currentlinewidth exch setlinewidth PStroke setlinewidth
+	} bind def
+/N { 
+	PStroke
+	} bind def
+/Nclip {
+	strokepath clip newpath
+	} bind def
+/Nstrk {
+	currentlinewidth exch setlinewidth PStroke setlinewidth
+	} bind def
+/M {newpath moveto} bind def
+/E {lineto} bind def
+/D {curveto} bind def
+/O {closepath} bind def
+/L { 
+ 	/n exch def
+	newpath
+	normalize
+	moveto 
+	2 1 n {pop normalize lineto} for
+	} bind def
+/Y { 
+	L 
+	closepath
+	} bind def
+/R { 
+	/y2 exch def
+	/x2 exch def
+	/y1 exch def
+	/x1 exch def
+	x1 y1
+	x2 y1
+	x2 y2
+	x1 y2
+	4 Y 
+	} bind def
+/rarc 
+	{rad 
+	 arcto
+	} bind def
+/RR { 
+	/rad exch def
+	normalize
+	/y2 exch def
+	/x2 exch def
+	normalize
+	/y1 exch def
+	/x1 exch def
+	mark
+	newpath
+	{
+	x1 y1 rad add moveto
+	x1 y2 x2 y2 rarc
+	x2 y2 x2 y1 rarc
+	x2 y1 x1 y1 rarc
+	x1 y1 x1 y2 rarc
+	closepath
+	} stopped {x1 y1 x2 y2 R} if 
+	cleartomark
+	} bind def
+/RRR { 
+	/rad exch def
+	normalize /y4 exch def /x4 exch def
+	normalize /y3 exch def /x3 exch def
+	normalize /y2 exch def /x2 exch def
+	normalize /y1 exch def /x1 exch def
+	newpath
+	normalize moveto 
+	mark
+	{
+	x2 y2 x3 y3 rarc
+	x3 y3 x4 y4 rarc
+	x4 y4 x1 y1 rarc
+	x1 y1 x2 y2 rarc
+	closepath
+	} stopped
+	 {x1 y1 x2 y2 x3 y3 x4 y4 newpath moveto lineto lineto lineto closepath} if
+	cleartomark
+	} bind def
+/C { 
+	grestore
+	gsave
+	R 
+	clip
+	setCurrentScreen
+} bind def
+/CP { 
+	grestore
+	gsave
+	Y 
+	clip
+	setCurrentScreen
+} bind def
+/F { 
+	FMfonts exch get
+	FMpointsize scalefont
+	setfont
+	} bind def
+/Q { 
+	/FMpointsize exch def
+	F 
+	} bind def
+/T { 
+	moveto show
+	} bind def
+/RF { 
+	rotate
+	0 ne {-1 1 scale} if
+	} bind def
+/TF { 
+	gsave
+	moveto 
+	RF
+	show
+	grestore
+	} bind def
+/P { 
+	moveto
+	0 32 3 2 roll widthshow
+	} bind def
+/PF { 
+	gsave
+	moveto 
+	RF
+	0 32 3 2 roll widthshow
+	grestore
+	} bind def
+/S { 
+	moveto
+	0 exch ashow
+	} bind def
+/SF { 
+	gsave
+	moveto
+	RF
+	0 exch ashow
+	grestore
+	} bind def
+/B { 
+	moveto
+	0 32 4 2 roll 0 exch awidthshow
+	} bind def
+/BF { 
+	gsave
+	moveto
+	RF
+	0 32 4 2 roll 0 exch awidthshow
+	grestore
+	} bind def
+/G { 
+	gsave
+	newpath
+	normalize translate 0.0 0.0 moveto 
+	dnormalize scale 
+	0.0 0.0 1.0 5 3 roll arc 
+	closepath 
+	PFill fill
+	grestore
+	} bind def
+/Gstrk {
+	savematrix
+    newpath
+    2 index 2 div add exch 3 index 2 div sub exch 
+    normalize 2 index 2 div sub exch 3 index 2 div add exch 
+    translate
+    scale 
+    0.0 0.0 1.0 5 3 roll arc 
+    restorematrix
+    currentlinewidth exch setlinewidth PStroke setlinewidth
+    } bind def
+/Gclip { 
+	newpath
+	savematrix
+	normalize translate 0.0 0.0 moveto 
+	dnormalize scale 
+	0.0 0.0 1.0 5 3 roll arc 
+	closepath 
+	clip newpath
+	restorematrix
+	} bind def
+/GG { 
+	gsave
+	newpath
+	normalize translate 0.0 0.0 moveto 
+	rotate 
+	dnormalize scale 
+	0.0 0.0 1.0 5 3 roll arc 
+	closepath
+	PFill
+	fill
+	grestore
+	} bind def
+/GGclip { 
+	savematrix
+	newpath
+    normalize translate 0.0 0.0 moveto 
+    rotate 
+    dnormalize scale 
+    0.0 0.0 1.0 5 3 roll arc 
+    closepath
+	clip newpath
+	restorematrix
+	} bind def
+/GGstrk { 
+	savematrix
+    newpath
+    normalize translate 0.0 0.0 moveto 
+    rotate 
+    dnormalize scale 
+    0.0 0.0 1.0 5 3 roll arc 
+    closepath 
+	restorematrix
+    currentlinewidth exch setlinewidth PStroke setlinewidth
+	} bind def
+/A { 
+	gsave
+	savematrix
+	newpath
+	2 index 2 div add exch 3 index 2 div sub exch 
+	normalize 2 index 2 div sub exch 3 index 2 div add exch 
+	translate 
+	scale 
+	0.0 0.0 1.0 5 3 roll arc 
+	restorematrix
+	PStroke
+	grestore
+	} bind def
+/Aclip {
+	newpath
+	savematrix
+	normalize translate 0.0 0.0 moveto 
+	dnormalize scale 
+	0.0 0.0 1.0 5 3 roll arc 
+	closepath 
+	strokepath clip newpath
+	restorematrix
+} bind def
+/Astrk {
+	Gstrk
+} bind def
+/AA { 
+	gsave
+	savematrix
+	newpath
+	
+	3 index 2 div add exch 4 index 2 div sub exch 
+	
+	normalize 3 index 2 div sub exch 4 index 2 div add exch
+	translate 
+	rotate 
+	scale 
+	0.0 0.0 1.0 5 3 roll arc 
+	restorematrix
+	PStroke
+	grestore
+	} bind def
+/AAclip {
+	savematrix
+	newpath
+    normalize translate 0.0 0.0 moveto 
+    rotate 
+    dnormalize scale 
+    0.0 0.0 1.0 5 3 roll arc 
+    closepath
+	strokepath clip newpath
+	restorematrix
+} bind def
+/AAstrk {
+	GGstrk
+} bind def
+/BEGINPRINTCODE { 
+	/FMdicttop countdictstack 1 add def 
+	/FMoptop count 7 sub def 
+	/FMsaveobject save def
+	userdict begin 
+	/showpage {} def 
+	FMNORMALIZEGRAPHICS 
+	3 index neg 3 index neg translate
+	} bind def
+/ENDPRINTCODE {
+	count -1 FMoptop {pop pop} for 
+	countdictstack -1 FMdicttop {pop end} for 
+	FMsaveobject restore 
+	} bind def
+/gn { 
+	0 
+	{	46 mul 
+		cf read pop 
+		32 sub 
+		dup 46 lt {exit} if 
+		46 sub add 
+		} loop
+	add 
+	} bind def
+/cfs { 
+	/str sl string def 
+	0 1 sl 1 sub {str exch val put} for 
+	str def 
+	} bind def
+/ic [ 
+	0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0223
+	0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0223
+	0
+	{0 hx} {1 hx} {2 hx} {3 hx} {4 hx} {5 hx} {6 hx} {7 hx} {8 hx} {9 hx}
+	{10 hx} {11 hx} {12 hx} {13 hx} {14 hx} {15 hx} {16 hx} {17 hx} {18 hx}
+	{19 hx} {gn hx} {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12}
+	{13} {14} {15} {16} {17} {18} {19} {gn} {0 wh} {1 wh} {2 wh} {3 wh}
+	{4 wh} {5 wh} {6 wh} {7 wh} {8 wh} {9 wh} {10 wh} {11 wh} {12 wh}
+	{13 wh} {14 wh} {gn wh} {0 bl} {1 bl} {2 bl} {3 bl} {4 bl} {5 bl} {6 bl}
+	{7 bl} {8 bl} {9 bl} {10 bl} {11 bl} {12 bl} {13 bl} {14 bl} {gn bl}
+	{0 fl} {1 fl} {2 fl} {3 fl} {4 fl} {5 fl} {6 fl} {7 fl} {8 fl} {9 fl}
+	{10 fl} {11 fl} {12 fl} {13 fl} {14 fl} {gn fl}
+	] def
+/ms { 
+	/sl exch def 
+	/val 255 def 
+	/ws cfs 
+	/im cfs 
+	/val 0 def 
+	/bs cfs 
+	/cs cfs 
+	} bind def
+400 ms 
+/ip { 
+	is 
+	0 
+	cf cs readline pop 
+	{	ic exch get exec 
+		add 
+		} forall 
+	pop 
+	
+	} bind def
+/rip { 
+	   
+	  
+	  bis ris copy pop 
+      is
+      0
+      cf cs readline pop 
+      {       ic exch get exec 
+              add 
+              } forall 
+	  pop pop 
+	  ris gis copy pop 
+	  dup is exch 
+	  
+      cf cs readline pop 
+      {       ic exch get exec 
+              add 
+              } forall 
+	  pop pop
+	  gis bis copy pop 
+	  dup add is exch 
+	  
+      cf cs readline pop 
+      {       ic exch get exec 
+              add 
+              } forall 
+      pop 
+      
+      } bind def
+/rip4 { 
+	   
+	  
+	  kis cis copy pop 
+      is
+      0
+      cf cs readline pop 
+      {       ic exch get exec 
+              add 
+              } forall 
+	  pop pop 
+	  cis mis copy pop 
+	  dup is exch 
+	  
+      cf cs readline pop 
+      {       ic exch get exec 
+              add 
+              } forall 
+	  pop pop
+	  mis yis copy pop 
+	  dup dup add is exch 
+	  
+      cf cs readline pop 
+      {       ic exch get exec 
+              add 
+              } forall 
+	  pop pop
+	  yis kis copy pop 
+	  3 mul is exch 
+	  
+      cf cs readline pop 
+      {       ic exch get exec 
+              add 
+              } forall 
+      pop 
+      
+      } bind def
+/wh { 
+	/len exch def 
+	/pos exch def 
+	ws 0 len getinterval im pos len getinterval copy pop
+	pos len 
+	} bind def
+/bl { 
+	/len exch def 
+	/pos exch def 
+	bs 0 len getinterval im pos len getinterval copy pop
+	pos len 
+	} bind def
+/s1 1 string def
+/fl { 
+	/len exch def 
+	/pos exch def 
+	/val cf s1 readhexstring pop 0 get def
+	pos 1 pos len add 1 sub {im exch val put} for
+	pos len 
+	} bind def
+/hx { 
+	3 copy getinterval 
+	cf exch readhexstring pop pop 
+	} bind def
+/wbytes { 
+      dup dup
+      8 gt { pop 8 idiv mul }
+      { 8 eq {pop} {1 eq {7 add 8 idiv} {3 add 4 idiv} ifelse} ifelse } ifelse
+	} bind def
+/BEGINBITMAPBWc { 
+	1 {} COMMONBITMAPc
+	} bind def
+/BEGINBITMAPGRAYc { 
+	8 {} COMMONBITMAPc
+	} bind def
+/BEGINBITMAP2BITc { 
+	2 {} COMMONBITMAPc
+	} bind def
+/COMMONBITMAPc { 
+		 
+	/cvtProc exch def
+	/depth exch def
+	gsave
+	
+	3 index 2 div add exch	
+	4 index 2 div add exch	
+	translate		
+	rotate			
+	1 index 2 div neg	
+	1 index 2 div neg	
+	translate		
+	scale			
+	/height exch def /width exch def
+	/lb width depth wbytes def 
+	sl lb lt {lb ms} if 
+	/bitmapsave save def 
+	cvtProc                
+	/is im 0 lb getinterval def 
+	ws 0 lb getinterval is copy pop 
+	/cf currentfile def 
+	width height depth [width 0 0 height neg 0 height] 
+	{ip} image 
+	bitmapsave restore 
+	grestore
+	} bind def
+/BEGINBITMAPBW { 
+	1 {} COMMONBITMAP
+	} bind def
+/BEGINBITMAPGRAY { 
+	8 {} COMMONBITMAP
+	} bind def
+/BEGINBITMAP2BIT { 
+	2 {} COMMONBITMAP
+	} bind def
+/COMMONBITMAP { 
+	/cvtProc exch def
+	/depth exch def
+	gsave
+	
+	3 index 2 div add exch	
+	4 index 2 div add exch	
+	translate		
+	rotate			
+	1 index 2 div neg	
+	1 index 2 div neg	
+	translate		
+	scale			
+	/height exch def /width exch def
+	/bitmapsave save def 
+	cvtProc              
+	/is width depth wbytes string def
+	/cf currentfile def 
+	width height depth [width 0 0 height neg 0 height] 
+	{cf is readhexstring pop} image
+	bitmapsave restore 
+	grestore
+	} bind def
+/ngrayt 256 array def
+/nredt 256 array def
+/nbluet 256 array def
+/ngreent 256 array def
+fMLevel1 {
+/colorsetup {
+	currentcolortransfer
+	/gryt exch def
+	/blut exch def
+	/grnt exch def
+	/redt exch def
+	0 1 255 {
+		/indx exch def
+		/cynu 1 red indx get 255 div sub def
+		/magu 1 green indx get 255 div sub def
+		/yelu 1 blue indx get 255 div sub def
+		/kk cynu magu min yelu min def
+		/u kk currentundercolorremoval exec def
+%		/u 0 def
+		nredt indx 1 0 cynu u sub max sub redt exec put
+		ngreent indx 1 0 magu u sub max sub grnt exec put
+		nbluet indx 1 0 yelu u sub max sub blut exec put
+		ngrayt indx 1 kk currentblackgeneration exec sub gryt exec put
+	} for
+	{255 mul cvi nredt exch get}
+	{255 mul cvi ngreent exch get}
+	{255 mul cvi nbluet exch get}
+	{255 mul cvi ngrayt exch get}
+	setcolortransfer
+	{pop 0} setundercolorremoval
+	{} setblackgeneration
+	} bind def
+}
+{
+/colorSetup2 {
+	[ /Indexed /DeviceRGB 255 
+		{dup red exch get 255 div 
+		 exch dup green exch get 255 div 
+		 exch blue exch get 255 div}
+	] setcolorspace
+} bind def
+} ifelse
+/fakecolorsetup {
+	/tran 256 string def
+	0 1 255 {/indx exch def 
+		tran indx
+		red indx get 77 mul
+		green indx get 151 mul
+		blue indx get 28 mul
+		add add 256 idiv put} for
+	currenttransfer
+	{255 mul cvi tran exch get 255.0 div}
+	exch fmConcatProcs settransfer
+} bind def
+/BITMAPCOLOR { 
+	/depth 8 def
+	gsave
+	
+	3 index 2 div add exch	
+	4 index 2 div add exch	
+	translate		
+	rotate			
+	1 index 2 div neg	
+	1 index 2 div neg	
+	translate		
+	scale			
+	/height exch def /width exch def
+	/bitmapsave save def
+	fMLevel1 {	
+		colorsetup
+		/is width depth wbytes string def
+		/cf currentfile def 
+		width height depth [width 0 0 height neg 0 height] 
+		{cf is readhexstring pop} {is} {is} true 3 colorimage 
+	} {
+		colorSetup2
+		/is width depth wbytes string def
+		/cf currentfile def 
+		7 dict dup begin
+			/ImageType 1 def
+			/Width width def
+			/Height height def
+			/ImageMatrix [width 0 0 height neg 0 height] def
+			/DataSource {cf is readhexstring pop} bind def
+			/BitsPerComponent depth def
+			/Decode [0 255] def
+		end image	
+	} ifelse
+	bitmapsave restore 
+	grestore
+	} bind def
+/BITMAPCOLORc { 
+	/depth 8 def
+	gsave
+	
+	3 index 2 div add exch	
+	4 index 2 div add exch	
+	translate		
+	rotate			
+	1 index 2 div neg	
+	1 index 2 div neg	
+	translate		
+	scale			
+	/height exch def /width exch def
+	/lb width depth wbytes def 
+	sl lb lt {lb ms} if 
+	/bitmapsave save def 
+	fMLevel1 {	
+		colorsetup
+		/is im 0 lb getinterval def 
+		ws 0 lb getinterval is copy pop 
+		/cf currentfile def 
+		width height depth [width 0 0 height neg 0 height] 
+		{ip} {is} {is} true 3 colorimage
+	} {
+		colorSetup2
+		/is im 0 lb getinterval def 
+		ws 0 lb getinterval is copy pop 
+		/cf currentfile def 
+		7 dict dup begin
+			/ImageType 1 def
+			/Width width def
+			/Height height def
+			/ImageMatrix [width 0 0 height neg 0 height] def
+			/DataSource {ip} bind def
+			/BitsPerComponent depth def
+			/Decode [0 255] def
+		end image	
+	} ifelse
+	bitmapsave restore 
+	grestore
+	} bind def
+/BITMAPTRUECOLORc { 
+	/depth 24 def
+        gsave
+ 	
+	3 index 2 div add exch	
+	4 index 2 div add exch	
+	translate		
+	rotate			
+	1 index 2 div neg	
+	1 index 2 div neg	
+	translate		
+	scale			
+	/height exch def /width exch def
+	/lb width depth wbytes def 
+	sl lb lt {lb ms} if 
+	/bitmapsave save def 
+        
+	/is im 0 lb getinterval def	
+	/ris im 0 width getinterval def	
+	/gis im width width getinterval def	
+	/bis im width 2 mul width getinterval def 
+        
+	ws 0 lb getinterval is copy pop 
+	/cf currentfile def 
+	width height 8 [width 0 0 height neg 0 height] 
+	{width rip pop ris} {gis} {bis} true 3 colorimage
+	bitmapsave restore 
+	grestore
+	} bind def
+/BITMAPCMYKc { 
+	/depth 32 def
+        gsave
+ 	
+	3 index 2 div add exch	
+	4 index 2 div add exch	
+	translate		
+	rotate			
+	1 index 2 div neg	
+	1 index 2 div neg	
+	translate		
+	scale			
+	/height exch def /width exch def
+	/lb width depth wbytes def 
+	sl lb lt {lb ms} if 
+	/bitmapsave save def 
+        
+	/is im 0 lb getinterval def	
+	/cis im 0 width getinterval def	
+	/mis im width width getinterval def	
+	/yis im width 2 mul width getinterval def 
+	/kis im width 3 mul width getinterval def 
+        
+	ws 0 lb getinterval is copy pop 
+	/cf currentfile def 
+	width height 8 [width 0 0 height neg 0 height] 
+	{width rip4 pop cis} {mis} {yis} {kis} true 4 colorimage
+	bitmapsave restore 
+	grestore
+	} bind def
+/BITMAPTRUECOLOR { 
+        gsave
+		
+		3 index 2 div add exch	
+		4 index 2 div add exch	
+		translate		
+		rotate			
+		1 index 2 div neg	
+		1 index 2 div neg	
+		translate		
+		scale			
+		/height exch def /width exch def
+        /bitmapsave save def 
+        /is width string def
+        /gis width string def
+        /bis width string def
+        /cf currentfile def 
+        width height 8 [width 0 0 height neg 0 height] 
+        { cf is readhexstring pop } 
+        { cf gis readhexstring pop } 
+        { cf bis readhexstring pop } 
+        true 3 colorimage 
+        bitmapsave restore 
+        grestore
+        } bind def
+/BITMAPCMYK { 
+        gsave
+		
+		3 index 2 div add exch	
+		4 index 2 div add exch	
+		translate		
+		rotate			
+		1 index 2 div neg	
+		1 index 2 div neg	
+		translate		
+		scale			
+		/height exch def /width exch def
+        /bitmapsave save def 
+        /is width string def
+        /mis width string def
+        /yis width string def
+        /kis width string def
+        /cf currentfile def 
+        width height 8 [width 0 0 height neg 0 height] 
+        { cf is readhexstring pop } 
+        { cf mis readhexstring pop } 
+        { cf yis readhexstring pop } 
+        { cf kis readhexstring pop } 
+        true 4 colorimage 
+        bitmapsave restore 
+        grestore
+        } bind def
+/BITMAPTRUEGRAYc { 
+	/depth 24 def
+        gsave
+	
+	3 index 2 div add exch	
+	4 index 2 div add exch	
+	translate		
+	rotate			
+	1 index 2 div neg	
+	1 index 2 div neg	
+	translate		
+	scale			
+	/height exch def /width exch def
+	/lb width depth wbytes def 
+	sl lb lt {lb ms} if 
+        /bitmapsave save def 
+        
+	/is im 0 lb getinterval def	
+	/ris im 0 width getinterval def	
+	/gis im width width getinterval def	
+	/bis im width 2 mul width getinterval def 
+        ws 0 lb getinterval is copy pop 
+        /cf currentfile def 
+        width height 8 [width 0 0 height neg 0 height] 
+        {width rip pop ris gis bis width gray} image
+        bitmapsave restore 
+        grestore
+        } bind def
+/BITMAPCMYKGRAYc { 
+	/depth 32 def
+        gsave
+	
+	3 index 2 div add exch	
+	4 index 2 div add exch	
+	translate		
+	rotate			
+	1 index 2 div neg	
+	1 index 2 div neg	
+	translate		
+	scale			
+	/height exch def /width exch def
+	/lb width depth wbytes def 
+	sl lb lt {lb ms} if 
+        /bitmapsave save def 
+        
+	/is im 0 lb getinterval def	
+	/cis im 0 width getinterval def	
+	/mis im width width getinterval def	
+	/yis im width 2 mul width getinterval def 
+	/kis im width 3 mul width getinterval def 
+        ws 0 lb getinterval is copy pop 
+        /cf currentfile def 
+        width height 8 [width 0 0 height neg 0 height] 
+        {width rip pop cis mis yis kis width cgray} image
+        bitmapsave restore 
+        grestore
+        } bind def
+/cgray { 
+        /ww exch def
+        /k exch def
+        /y exch def
+        /m exch def
+        /c exch def
+        0 1 ww 1 sub { /i exch def c i get m i get y i get k i get CMYKtoRGB
+				.144 mul 3 1 roll .587 mul 3 1 roll .299 mul add add
+				c i 3 -1 roll floor cvi put } for
+        c
+ 		} bind def
+/gray { 
+        /ww exch def
+        /b exch def
+        /g exch def
+        /r exch def
+        0 1 ww 1 sub { /i exch def r i get .299 mul g i get .587 mul
+			b i get .114 mul add add r i 3 -1 roll floor cvi put } for
+        r
+        } bind def
+/BITMAPTRUEGRAY { 
+        gsave
+		
+		3 index 2 div add exch	
+		4 index 2 div add exch	
+		translate		
+		rotate			
+		1 index 2 div neg	
+		1 index 2 div neg	
+		translate		
+		scale			
+		/height exch def /width exch def
+        /bitmapsave save def 
+        /is width string def
+        /gis width string def
+        /bis width string def
+        /cf currentfile def 
+        width height 8 [width 0 0 height neg 0 height] 
+        { cf is readhexstring pop 
+          cf gis readhexstring pop 
+          cf bis readhexstring pop width gray}  image
+        bitmapsave restore 
+        grestore
+        } bind def
+/BITMAPCMYKGRAY { 
+        gsave
+		
+		3 index 2 div add exch	
+		4 index 2 div add exch	
+		translate		
+		rotate			
+		1 index 2 div neg	
+		1 index 2 div neg	
+		translate		
+		scale			
+		/height exch def /width exch def
+        /bitmapsave save def 
+        /is width string def
+        /yis width string def
+        /mis width string def
+        /kis width string def
+        /cf currentfile def 
+        width height 8 [width 0 0 height neg 0 height] 
+        { cf is readhexstring pop 
+          cf mis readhexstring pop 
+          cf yis readhexstring pop 
+          cf kis readhexstring pop width cgray}  image
+        bitmapsave restore 
+        grestore
+        } bind def
+/BITMAPGRAY { 
+	8 {fakecolorsetup} COMMONBITMAP
+	} bind def
+/BITMAPGRAYc { 
+	8 {fakecolorsetup} COMMONBITMAPc
+	} bind def
+/ENDBITMAP {
+	} bind def
+end 
+	/ALDmatrix matrix def ALDmatrix currentmatrix pop
+/StartALD {
+	/ALDsave save def
+	 savematrix
+	 ALDmatrix setmatrix
+	} bind def
+/InALD {
+	 restorematrix
+	} bind def
+/DoneALD {
+	 ALDsave restore
+	} bind def
+/I { setdash } bind def
+/J { [] 0 setdash } bind def
+%%EndProlog
+%%BeginSetup
+(5.0) FMVERSION
+1 1 0 0 612 792 0 1 26 FMDOCUMENT
+0 0 /Helvetica-Bold FMFONTDEFINE
+1 0 /Times-Roman FMFONTDEFINE
+2 0 /Courier FMFONTDEFINE
+3 0 /Times-Italic FMFONTDEFINE
+4 0 /Times-Bold FMFONTDEFINE
+5 0 /Helvetica FMFONTDEFINE
+6 0 /Courier-Oblique FMFONTDEFINE
+7 0 /Courier-Bold FMFONTDEFINE
+32 FMFILLS
+0 0 FMFILL
+1 0.1 FMFILL
+2 0.3 FMFILL
+3 0.5 FMFILL
+4 0.7 FMFILL
+5 0.9 FMFILL
+6 0.97 FMFILL
+7 1 FMFILL
+8 <0f1e3c78f0e1c387> FMFILL
+9 <0f87c3e1f0783c1e> FMFILL
+10 <cccccccccccccccc> FMFILL
+11 <ffff0000ffff0000> FMFILL
+12 <8142241818244281> FMFILL
+13 <03060c183060c081> FMFILL
+14 <8040201008040201> FMFILL
+16 1 FMFILL
+17 0.9 FMFILL
+18 0.7 FMFILL
+19 0.5 FMFILL
+20 0.3 FMFILL
+21 0.1 FMFILL
+22 0.03 FMFILL
+23 0 FMFILL
+24 <f0e1c3870f1e3c78> FMFILL
+25 <f0783c1e0f87c3e1> FMFILL
+26 <3333333333333333> FMFILL
+27 <0000ffff0000ffff> FMFILL
+28 <7ebddbe7e7dbbd7e> FMFILL
+29 <fcf9f3e7cf9f3f7e> FMFILL
+30 <7fbfdfeff7fbfdfe> FMFILL
+%%EndSetup
+%%Page: "1" 1
+%%BeginPaperSize: Letter
+%%EndPaperSize
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+J
+0 0 0 1 0 0 0 K
+0 16 Q
+0 X
+0 0 0 1 0 0 0 K
+(Python Reference Manual) 221.7 709.33 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(Guido van Rossum) 273.5 672 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(Corporation for National Research Initiatives \050CNRI\051) 201.73 656.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(1895 Preston White Drive, Reston, Va 20191, USA) 205.84 643.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(E-mail:) 170.18 630.67 T
+0 0 0 1 0 0 0 K
+2 F
+(guido@cnri.reston.va.us) 205.93 630.67 T
+0 0 0 1 0 0 0 K
+1 F
+(,) 357.73 630.67 T
+0 0 0 1 0 0 0 K
+2 F
+(guido@python.org) 363.23 630.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+(A) 293.56 585 T
+1 9.6 Q
+(BSTRACT) 302.23 585 T
+0 0 0 1 0 0 0 K
+1 11 Q
+0.66 (Python is a simple, yet powerful, interpreted programming language that) 156.6 563.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.27 (bridges the gap between C and shell programming, and is thus ideally suit-) 156.6 550.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.08 (ed for \322throw-away programming\323 and rapid prototyping. Its syntax is put) 156.6 537.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.29 (together from constructs borrowed from a variety of other languages; most) 156.6 524.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(prominent are influences from ABC, C, Modula-3 and Icon.) 156.6 511.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.68 (The Python interpreter is easily extended with new functions and data types) 156.6 488.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1.34 (implemented in C. Python is also suitable as an extension language for) 156.6 475.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(highly customizable C applications such as editors or window managers.) 156.6 462.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.2 (Python is available for various systems, amongst which most common fla-) 156.6 439.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1.57 (vors of UNIX \050including Linux\051, the Apple Macintosh, MS-DOS, MS-) 156.6 426.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Windows 3.1\0501\051, Windows 95, Windows NT, and OS/2.) 156.6 413.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1.18 (This reference manual describes the syntax and \322core semantics\323 of the) 156.6 390.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.01 (language. It is terse, but attempts to be exact and complete. The semantics) 156.6 377.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.46 (of non-essential built-in object types and of the built-in functions and mod-) 156.6 364.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.07 (ules are described in the) 156.6 351.67 P
+3 F
+0.07 (Python Library Reference) 265.99 351.67 P
+1 F
+0.07 (. For an informal intro-) 380.39 351.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(duction to the language, see the) 156.6 338.67 T
+3 F
+(Python Tutorial) 298.05 338.67 T
+1 F
+(.) 368.03 338.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 F
+(Copyright \251 1996 Corporation for National Research Initiatives.) 99 290.67 T
+(Copyright \251 1991-1995 by Stichting Mathematisch Centrum, Amsterdam, The Netherlands.) 99 277.67 T
+0 0 0 1 0 0 0 K
+1 F
+(All Rights Reserved) 274.89 258.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.18 (Permission to use, copy, modify, and distribute this software and its documentation for any purpose) 99 233.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.24 (and without fee is hereby granted, provided that the above copyright notice appear in all copies and) 99 220.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.03 (that both that copyright notice and this permission notice appear in supporting documentation, and) 99 207.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.06 (that the names of the copyright holders not be used in advertising or publicity pertaining to distribu-) 99 194.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(tion of the software without specific, written prior permission.) 99 181.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.28 (THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS) 99 156.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.22 (SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND) 99 143.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.03 (FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPE-) 99 130.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.08 (CIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER) 99 117.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.25 (RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF) 99 104.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.29 (CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN) 99 91.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.) 99 78.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "1" 1
+%%Page: "2" 2
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "2" 2
+%%Page: "i" 3
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 1 1 0 1 0 0 K
+53.79 62.85 89.79 98.85 R
+3 X
+0 1 1 0 1 0 0 K
+V
+59.44 64 86.44 83.88 R
+V
+0 0 0 0 1 1 1 K
+0 12 Q
+7 X
+0 0 0 0 1 1 1 K
+(i) 59.44 75.88 T
+0 1 1 0 1 0 0 K
+0 0 0 1 0 0 0 K
+37 98.81 614.38 98.81 2 L
+0.75 H
+2 Z
+3 X
+0 0 0 1 0 0 0 K
+N
+90.23 21.88 90.23 98.81 2 L
+N
+0 9 612 783 R
+1 H
+0 X
+N
+-83.3 458.43 132 458.43 2 L
+0.75 H
+3 X
+N
+-83.3 278.14 131.29 278.14 2 L
+N
+-84 620.73 132 620.73 2 L
+N
+0 1 1 0 1 0 0 K
+0 36 Q
+0 X
+0 1 1 0 1 0 0 K
+(T) 259.91 714 T
+(ab) 279.02 714 T
+(le of Contents) 320.68 714 T
+0 0 0 1 0 0 0 K
+5 10 Q
+0 0 0 1 0 0 0 K
+(CHAPTER) 144 628.3 T
+0 1 1 0 1 0 0 K
+4 36 Q
+0 1 1 0 1 0 0 K
+(1) 194.56 628.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Introduction) 216 628.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 301 628.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(1) 534.01 628.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(Notation) 216 611.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 258 611.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(1) 535.01 611.63 T
+0 0 0 1 0 0 0 K
+5 10 Q
+(CHAPTER) 144 578.3 T
+0 1 1 0 1 0 0 K
+4 36 Q
+0 1 1 0 1 0 0 K
+(2) 194.56 578.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Lexical analysis) 216 578.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 322 578.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(3) 534.01 578.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(Line structure) 216 561.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 285 561.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(3) 535.01 561.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Logical lines) 216 546.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 279 546.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(3) 535.01 546.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Physical lines) 216 531.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 285 531.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(3) 535.01 531.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Comments) 216 516.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 270 516.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(3) 535.01 516.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Explicit line joining) 216 501.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 315 501.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(3) 535.01 501.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Implicit line joining) 216 486.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 315 486.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(4) 535.01 486.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Blank lines) 216 471.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 273 471.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(4) 535.01 471.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Indentation) 216 456.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 273 456.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(4) 535.01 456.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Whitespace between tokens) 216 441.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 351 441.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(5) 535.01 441.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Other tokens) 216 426.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 279 426.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(5) 535.01 426.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Identifiers and keywords) 216 411.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 336 411.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(5) 535.01 411.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Keywords) 216 396.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 267 396.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(5) 535.01 396.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Reserved classes of identifiers) 216 381.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 363 381.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(6) 535.01 381.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Literals) 216 366.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 255 366.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(6) 535.01 366.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(String literals) 216 351.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 282 351.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(6) 535.01 351.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(String literal concatenation) 235.01 336.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 369 336.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(7) 535.01 336.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Numeric literals) 216 322.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 294 322.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(8) 535.01 322.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Integer and long integer literals) 235.01 307.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 390 307.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(8) 535.01 307.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Floating point literals) 235.01 293.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 342 293.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(8) 535.01 293.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Imaginary literals) 235.01 279.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 324 279.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(8) 535.01 279.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Operators) 216 265.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 264 265.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(9) 535.01 265.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Delimiters) 216 250.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 267 250.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(9) 535.01 250.63 T
+0 0 0 1 0 0 0 K
+5 10 Q
+(CHAPTER) 144 217.3 T
+0 1 1 0 1 0 0 K
+4 36 Q
+0 1 1 0 1 0 0 K
+(3) 194.56 217.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Data model) 216 217.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 297.5 217.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(11) 527.01 217.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(Objects, values and types) 216 200.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 339 200.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(11) 529.01 200.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The standard type hierarchy) 216 185.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 351 185.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(12) 529.01 185.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Special method names) 216 170.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 324 170.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(18) 529.01 170.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Basic customization) 216 155.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 315 155.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(18) 529.01 155.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Customizing attribute access) 216 140.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 354 140.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(19) 529.01 140.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Emulating callable objects) 216 125.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 345 125.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(20) 529.01 125.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "i" 3
+%%Page: "ii" 4
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 1 1 0 1 0 0 K
+486 63 522 99 R
+3 X
+0 1 1 0 1 0 0 K
+V
+491.65 64.15 518.65 84.03 R
+V
+0 0 0 0 1 1 1 K
+0 12 Q
+7 X
+0 0 0 0 1 1 1 K
+(ii) 491.65 76.03 T
+0 1 1 0 1 0 0 K
+0 0 0 1 0 0 0 K
+55.04 98.81 614.38 98.81 2 L
+0.75 H
+2 Z
+3 X
+0 0 0 1 0 0 0 K
+N
+486 -97.92 486 99 2 L
+N
+0 9 612 783 R
+1 H
+0 X
+N
+531.54 458.43 696 458.43 2 L
+0.75 H
+3 X
+N
+531.54 278.14 695.46 278.14 2 L
+N
+531 620.73 696 620.73 2 L
+N
+0 1 1 0 1 0 0 K
+0 36 Q
+0 X
+0 1 1 0 1 0 0 K
+(T) 221.22 714 T
+(ab) 240.34 714 T
+(le of Contents) 281.99 714 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(Emulating sequence and mapping types) 178.99 629.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .) 372 629.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(20) 492 629.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Additional methods for emulation of sequence types) 198 614.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .) 453 614.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(20) 492 614.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Emulating numeric types) 178.99 600.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 300 600.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(21) 492 600.63 T
+0 0 0 1 0 0 0 K
+5 10 Q
+(CHAPTER) 106.99 567.3 T
+0 1 1 0 1 0 0 K
+4 36 Q
+0 1 1 0 1 0 0 K
+(4) 157.55 567.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Execution model) 178.99 567.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 287 567.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(23) 490 567.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(Code blocks, execution frames, and name spaces) 178.99 550.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .) 414 550.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(23) 492 550.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Exceptions) 178.99 535.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 234 535.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(25) 492 535.63 T
+0 0 0 1 0 0 0 K
+5 10 Q
+(CHAPTER) 106.99 502.3 T
+0 1 1 0 1 0 0 K
+4 36 Q
+0 1 1 0 1 0 0 K
+(5) 157.55 502.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Expressions) 178.99 502.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 262.5 502.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(27) 490 502.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(Arithmetic conversions) 178.99 485.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 294 485.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(27) 492 485.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Atoms) 178.99 470.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 213 470.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(27) 492 470.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Identifiers \050Names\051) 178.99 455.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 273 455.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(27) 492 455.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Literals) 178.99 440.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 216 440.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(27) 492 440.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Parenthesized forms) 178.99 425.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 279 425.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(28) 492 425.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(List displays) 178.99 410.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 240 410.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(28) 492 410.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Dictionary displays) 178.99 395.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 273 395.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(28) 492 395.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(String conversions) 178.99 380.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 270 380.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(29) 492 380.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Primaries) 178.99 365.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 225 365.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(29) 492 365.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Attribute references) 178.99 350.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 276 350.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(29) 492 350.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Subscriptions) 178.99 335.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 246 335.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(29) 492 335.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Slicings) 178.99 320.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 219 320.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(30) 492 320.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Calls) 178.99 305.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 204 305.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(31) 492 305.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The power operator) 178.99 290.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 276 290.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(32) 492 290.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Unary arithmetic operations) 178.99 275.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 315 275.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(32) 492 275.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Binary arithmetic operations) 178.99 260.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 318 260.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(32) 492 260.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Shifting operations) 178.99 245.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 273 245.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(33) 492 245.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Binary bit-wise operations) 178.99 230.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 309 230.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(33) 492 230.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Comparisons) 178.99 215.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 243 215.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(34) 492 215.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Boolean operations) 178.99 200.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 273 200.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(35) 492 200.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Expression lists) 178.99 185.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 255 185.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(36) 492 185.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Summary) 178.99 170.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 228 170.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(37) 492 170.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "ii" 4
+%%Page: "iii" 5
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 1 1 0 1 0 0 K
+53.79 62.85 89.79 98.85 R
+3 X
+0 1 1 0 1 0 0 K
+V
+59.44 64 86.44 83.88 R
+V
+0 0 0 0 1 1 1 K
+0 12 Q
+7 X
+0 0 0 0 1 1 1 K
+(iii) 59.44 75.88 T
+0 1 1 0 1 0 0 K
+0 0 0 1 0 0 0 K
+37 98.81 614.38 98.81 2 L
+0.75 H
+2 Z
+3 X
+0 0 0 1 0 0 0 K
+N
+90.23 21.88 90.23 98.81 2 L
+N
+0 9 612 783 R
+1 H
+0 X
+N
+-83.3 458.43 132 458.43 2 L
+0.75 H
+3 X
+N
+-83.3 278.14 131.29 278.14 2 L
+N
+-84 620.73 132 620.73 2 L
+N
+0 1 1 0 1 0 0 K
+0 36 Q
+0 X
+0 1 1 0 1 0 0 K
+(T) 259.91 714 T
+(ab) 279.02 714 T
+(le of Contents) 320.68 714 T
+0 0 0 1 0 0 0 K
+5 10 Q
+0 0 0 1 0 0 0 K
+(CHAPTER) 144 628.3 T
+0 1 1 0 1 0 0 K
+4 36 Q
+0 1 1 0 1 0 0 K
+(6) 194.56 628.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Simple statements) 216 628.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 332.5 628.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(39) 527.01 628.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(Expression statements) 216 611.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 324 611.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(39) 529.01 611.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Assignment statements) 216 596.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 327 596.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(39) 529.01 596.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The pass statement) 216 581.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 309 581.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(41) 529.01 581.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The del statement) 216 566.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 303 566.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(41) 529.01 566.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The print statement) 216 551.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 312 551.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(41) 529.01 551.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The return statement) 216 536.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 318 536.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(42) 529.01 536.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The raise statement) 216 521.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 312 521.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(42) 529.01 521.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The break statement) 216 506.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 315 506.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(42) 529.01 506.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The continue statement) 216 491.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 330 491.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(43) 529.01 491.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The import statement) 216 476.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 321 476.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(43) 529.01 476.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The global statement) 216 461.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 318 461.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(44) 529.01 461.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The exec statement) 216 446.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 309 446.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(44) 529.01 446.63 T
+0 0 0 1 0 0 0 K
+5 10 Q
+(CHAPTER) 144 413.3 T
+0 1 1 0 1 0 0 K
+4 36 Q
+0 1 1 0 1 0 0 K
+(7) 194.56 413.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Compound statements) 216 413.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 357 413.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(45) 527.01 413.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(The if statement) 216 396.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 294 396.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(45) 529.01 396.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 216 381.63 T
+0 0 0 1 0 0 0 K
+2 F
+(while) 237.66 381.63 T
+0 0 0 1 0 0 0 K
+1 F
+( statement) 273.66 381.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 324 381.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(46) 529.01 381.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 216 366.63 T
+0 0 0 1 0 0 0 K
+2 F
+(for) 237.66 366.63 T
+0 0 0 1 0 0 0 K
+1 F
+( statement) 259.26 366.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 309 366.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(46) 529.01 366.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 216 351.63 T
+0 0 0 1 0 0 0 K
+2 F
+(try) 237.66 351.63 T
+0 0 0 1 0 0 0 K
+1 F
+( statement) 259.26 351.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 309 351.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(47) 529.01 351.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Function definitions) 216 336.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 315 336.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(48) 529.01 336.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Class definitions) 216 321.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 297 321.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(49) 529.01 321.63 T
+0 0 0 1 0 0 0 K
+5 10 Q
+(CHAPTER) 144 288.3 T
+0 1 1 0 1 0 0 K
+4 36 Q
+0 1 1 0 1 0 0 K
+(8) 194.56 288.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Top-level components) 216 288.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 353.5 288.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(51) 527.01 288.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+0 0 0 1 0 0 0 K
+(Complete Python programs) 216 271.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 348 271.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(51) 529.01 271.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(File input) 216 256.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 264 256.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(51) 529.01 256.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Interactive input) 216 241.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 297 241.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(51) 529.01 241.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Expression input) 216 226.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 297 226.63 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(52) 529.01 226.63 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+3 14 Q
+1 1 0 0 0 0 1 K
+(Index) 216 193.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+( .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .) 248.5 193.3 T
+0 0 0 1 0 0 0 K
+1 1 0 0 0 0 1 K
+(53) 527.01 193.3 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "iii" 5
+%%Page: "iv" 6
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "iv" 6
+%%Page: "1" 7
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(1) 535 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Introduction) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 16 Q
+(C) 99 709.33 T
+0 12.8 Q
+(HAPTER) 110.55 709.33 T
+0 16 Q
+(1:) 167.62 709.33 T
+(I) 198 709.33 T
+0 12.8 Q
+(NTRODUCTION) 202.45 709.33 T
+1 11 Q
+(This reference manual describes the Python programming language. It is not intended as a tutorial.) 99 672.67 T
+-0.04 (While I am trying to be as precise as possible, I have chosen to use English rather than formal speci-) 99 653.67 P
+-0.21 (fications for everything except syntax and lexical analysis. This should make the document more un-) 99 640.67 P
+0.58 (derstandable to the average reader, but will leave room for ambiguities. Consequently, if you were) 99 627.67 P
+0.6 (coming from Mars and tried to re-implement Python from this document alone, you might have to) 99 614.67 P
+-0.03 (guess things and in fact you would probably end up implementing quite a different language. On the) 99 601.67 P
+0.25 (other hand, if you are using Python and wonder what the precise rules about a particular area of the) 99 588.67 P
+-0.06 (language are, you should definitely be able to find them here. If you would like to see a more formal) 99 575.67 P
+(definitition of the language, maybe you could volunteer your time \321 or invent a cloning machine.) 99 562.67 T
+-0.01 (It is dangerous to add too many implementation details to a language reference document \321 the im-) 99 543.67 P
+-0.46 (plementation may change, and other implementations of the same language may work differently. On) 99 530.67 P
+-0.28 (the other hand, there is currently only one Python implementation, and its particular quirks are some-) 99 517.67 P
+0.71 (times worth being mentioned, especially where the implementation imposes additional limitations.) 99 504.67 P
+(Therefore, you\325ll find short \322implementation notes\323 sprinkled throughout the text.) 99 491.67 T
+0.1 (Every Python implementation comes with a number of built-in and standard modules. These are not) 99 472.67 P
+-0.53 (documented here, but in the separate) 99 459.67 P
+3 F
+-0.53 (Python Library Reference) 259.84 459.67 P
+1 F
+-0.53 ( document. A few built-in modules are) 373.03 459.67 P
+(mentioned when they interact in a significant way with the language definition.) 99 446.67 T
+0 14 Q
+(1.1) 99 419.67 T
+(Notation) 135 419.67 T
+1 11 Q
+-0.01 (The descriptions of lexical analysis and syntax use a modified BNF grammar notation. This uses the) 99 394.67 P
+(following style of definition:) 99 381.67 T
+2 10 Q
+(name:           lc_letter \050lc_letter | "_"\051*) 99 363.33 T
+(lc_letter:      "a"..."z") 99 351.33 T
+1 11 Q
+0.41 0.43 (The first line says that a) 99 326.67 B
+2 F
+0.99 0.43 (name) 221.35 326.67 B
+1 F
+0.41 0.43 ( is an) 249.48 326.67 B
+2 F
+0.99 0.43 (lc_letter) 279.73 326.67 B
+1 F
+0.41 0.43 ( followed by a sequence of zero or more) 343.04 326.67 B
+2 F
+0.93 (lc_letter) 99 313.67 P
+1 F
+0.39 (s and underscores. An) 158.4 313.67 P
+2 F
+0.93 (lc_letter) 259.84 313.67 P
+1 F
+0.39 ( in turn is any of the single characters \324a\325 through) 319.24 313.67 P
+0.41 0.04 (\324z\325. \050This rule is actually adhered to for the names used in lexical and grammar rules in this docu-) 99 300.67 B
+(ment.\051) 99 287.67 T
+-0.01 (Each rule begins with a name \050which is the name defined by the rule\051 and a colon. A vertical bar \050) 99 262.67 P
+2 F
+-0.04 (|) 529.74 262.67 P
+1 F
+-0.01 (\051) 536.34 262.67 P
+0.01 (is used to separate alternatives; it is the least binding operator in this notation. A star \050) 99 249.67 P
+2 F
+0.04 (*) 477.17 249.67 P
+1 F
+0.01 (\051 means zero) 483.77 249.67 P
+0.3 (or more repetitions of the preceding item; likewise, a plus \050) 99 236.67 P
+2 F
+0.73 (+) 362.64 236.67 P
+1 F
+0.3 (\051 means one or more repetitions, and a) 369.24 236.67 P
+-0.55 (phrase enclosed in square brackets \050) 99 223.67 P
+2 F
+-1.31 ([ ]) 254.8 223.67 P
+1 F
+-0.55 (\051 means zero or one occurrences \050in other words, the enclosed) 273.29 223.67 P
+-0.25 (phrase is optional\051. The) 99 210.67 P
+2 F
+-0.59 (*) 204.64 210.67 P
+1 F
+-0.25 ( and) 211.24 210.67 P
+2 F
+-0.59 (+) 232.13 210.67 P
+1 F
+-0.25 ( operators bind as tightly as possible; parentheses are used for group-) 238.73 210.67 P
+0.19 (ing. Literal strings are enclosed in quotes. White space is only meaningful to separate tokens. Rules) 99 197.67 P
+0.12 (are normally contained on a single line; rules with many alternatives may be formatted alternatively) 99 184.67 P
+(with each line after the first beginning with a vertical bar.) 99 171.67 T
+0.16 (In lexical definitions \050as in the example above\051, two more conventions are used: Two literal charac-) 99 146.67 P
+0.41 0.02 (ters separated by three dots mean a choice of any single character in the given \050inclusive\051 range of) 99 133.67 B
+0.23 (ASCII characters. A phrase between angular brackets \050) 99 120.67 P
+2 F
+0.54 (<...>) 342.5 120.67 P
+1 F
+0.23 (\051 gives an informal description of the) 375.5 120.67 P
+-0.18 (symbol defined; e.g. this could be used to describe the notion of \324control character\325 if needed.) 99 107.67 P
+0 1 1 0 1 0 0 K
+0 1 1 0 1 0 0 K
+540 106.57 510.67 106.57 2 L
+0 1 1 0 1 0 0 K
+V
+0.55 H
+0 Z
+N
+0 0 0 1 0 0 0 K
+0 1 1 0 1 0 0 K
+-0.18 (lexical) 510.67 107.67 P
+0 0 0 1 0 0 0 K
+0 1 1 0 1 0 0 K
+0 1 1 0 1 0 0 K
+148.81 93.57 99 93.57 2 L
+V
+N
+0 0 0 1 0 0 0 K
+0 1 1 0 1 0 0 K
+(definitions) 99 94.67 T
+0 0 0 1 0 0 0 K
+0 1 1 0 1 0 0 K
+0 1 1 0 1 0 0 K
+183.03 93.57 151.56 93.57 2 L
+V
+N
+0 0 0 1 0 0 0 K
+0 1 1 0 1 0 0 K
+(ASCII) 151.56 94.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "1" 7
+%%Page: "2" 8
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(2) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.35 (Even though the notation used is almost the same, there is a big difference between the meaning of) 76.5 712.67 P
+-0.32 (lexical and syntactic definitions: a lexical definition operates on the individual characters of the input) 76.5 699.67 P
+0.3 (source, while a syntax definition operates on the stream of tokens generated by the lexical analysis.) 76.5 686.67 P
+0.34 (All uses of BNF in the next chapter \050\322Lexical Analysis\323\051 are lexical definitions; uses in subsequent) 76.5 673.67 P
+(chapters are syntactic definitions.) 76.5 660.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "2" 8
+%%Page: "3" 9
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(3) 535 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Lexical analysis) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 16 Q
+(C) 99 709.33 T
+0 12.8 Q
+(HAPTER) 110.55 709.33 T
+0 16 Q
+(2:) 167.62 709.33 T
+(L) 198 709.33 T
+0 12.8 Q
+(EXICAL) 207.78 709.33 T
+(ANALYSIS) 259.16 709.33 T
+1 11 Q
+-0.07 (A Python program is read by a) 99 672.67 P
+3 F
+-0.07 (parser) 236.31 672.67 P
+1 F
+-0.07 (. Input to the parser is a stream of) 265.03 672.67 P
+3 F
+-0.07 (tokens) 414.73 672.67 P
+1 F
+-0.07 (, generated by the) 442.83 672.67 P
+3 F
+-0.07 (lex-) 523.51 672.67 P
+(ical analyzer) 99 659.67 T
+1 F
+(. This chapter describes how the lexical analyzer breaks a file into tokens.) 156.13 659.67 T
+0.15 (Python uses the \0507-bit\051 ASCII character set for program text and string literals. 8-bit characters may) 99 634.67 P
+-0.19 (be used in string literals and comments but their interpretation is platform dependent; the proper way) 99 621.67 P
+(to insert 8-bit characters in string literals is by using octal or hexadecimal escape sequences.) 99 608.67 T
+-0.35 (The run-time character set depends on the I/O devices connected to the program but is generally a su-) 99 583.67 P
+(perset of ASCII.) 99 570.67 T
+0 14 Q
+(2.1) 99 543.67 T
+(Line structure) 135 543.67 T
+1 11 Q
+(A Python program is divided in a number of) 99 518.67 T
+3 F
+(logical lines) 296.68 518.67 T
+1 F
+(.) 350.77 518.67 T
+0 12 Q
+(2.1.1) 99 493 T
+(Logical lines) 144 493 T
+1 11 Q
+0.07 (The end of each logical line is represented by the token NEWLINE. Statements cannot cross logical) 99 473.67 P
+0.21 (line boundaries except where NEWLINE is allowed by the syntax \050e.g. between statements in com-) 99 460.67 P
+-0.22 (pound statements\051. A logical line is constructed from one or more) 99 447.67 P
+3 F
+-0.22 (physical lines) 388.64 447.67 P
+1 F
+-0.22 ( by following the ex-) 448.61 447.67 P
+(plicit or implicit) 99 434.67 T
+3 F
+(line joining) 173.26 434.67 T
+1 F
+( rules.) 223.68 434.67 T
+0 12 Q
+(2.1.2) 99 409 T
+(Physical lines) 144 409 T
+1 11 Q
+-0.52 (A physical line ends in whatever the current platform\325s convention is for terminating lines. On UNIX,) 99 389.67 P
+-0.24 (this is the ASCII LF \050linefeed\051 character. On DOS/Windows, it is the ASCII sequence CR LF \050return) 99 376.67 P
+(followed by linefeed\051. On Macintosh, it is the ASCII CR \050return\051 character.) 99 363.67 T
+0 12 Q
+(2.1.3) 99 338 T
+(Comments) 144 338 T
+1 11 Q
+0.35 (A comment starts with a hash character \050) 99 318.67 P
+2 F
+0.84 (#) 281.36 318.67 P
+1 F
+0.35 (\051 that is not part of a string literal, and ends at the end of) 287.96 318.67 P
+-0.23 (the physical line. A comment signifies the end of the logical line unless the implicit line joining rules) 99 305.67 P
+(are invoked. Comments are ignored by the syntax\255\255; they are not tokens.) 99 292.67 T
+0 12 Q
+(2.1.4) 99 267 T
+(Explicit line joining) 144 267 T
+1 11 Q
+-0.63 (Two or more physical lines may be joined into logical lines using backslash characters \050) 99 247.67 P
+2 F
+-1.52 (\134) 477.53 247.67 P
+1 F
+-0.63 (\051, as follows:) 484.13 247.67 P
+-0.39 (when a physical line ends in a backslash that is not part of a string literal or comment, it is joined with) 99 234.67 P
+-0.34 (the following forming a single logical line, deleting the backslash and the following end-of-line char-) 99 221.67 P
+(acter. For example:) 99 208.67 T
+2 10 Q
+(if 1900 < year < 2100 and 1 <= month <= 12 \134) 99 190.33 T
+(   and 1 <= day <= 31 and 0 <= hour < 24 \134) 99 178.33 T
+-0.13 (   and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date) 99 166.33 P
+(        return 1) 99 154.33 T
+1 11 Q
+0.22 (A line ending in a backslash cannot carry a comment. A backslash does not continue a comment. A) 99 129.67 P
+-0.49 (backslash does not continue a token except for string literals \050i.e., tokens other than string literals can-) 99 116.67 P
+-0.33 (not be split across physical lines using a backslash\051. A backslash is illegal elsewhere on a line outside) 99 103.67 P
+(a string literal.) 99 90.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "3" 9
+%%Page: "4" 10
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(4) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+(2.1.5) 72 712 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Implicit line joining) 117 712 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.51 (Expressions in parentheses, square brackets or curly braces can be split over more than one physical line) 72 692.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(without using backslashes. For example:) 72 679.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(month_names = [\325Januari\325, \325Februari\325, \325Maart\325,      # These are the) 72 661.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(               \325April\325,   \325Mei\325,      \325Juni\325,       # Dutch names) 72 649.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(               \325Juli\325,    \325Augustus\325, \325September\325,  # for the months) 72 637.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(               \325Oktober\325, \325November\325, \325December\325]   # of the year) 72 625.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.3 (Implicitly continued lines can carry comments. The indentation of the continuation lines is not important.) 72 600.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.53 (Blank continuation lines are allowed. There is no NEWLINE token between implicit continuation lines. Im-) 72 587.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.04 (plicit continued lines can also occur within triple-quoted strings \050see below\051; in that case they cannot carry) 72 574.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(comments.) 72 561.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+(2.1.6) 72 536 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Blank lines) 117 536 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.4 (A logical line that contains only spaces, tabs, formfeeds, and possibly a comment, is ignored \050i.e., no NEW-) 72 516.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.3 (LINE token is generated\051, except that during interactive input of statements, an entirely blank logical line) 72 503.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\050i.e. one containing not even whitespace or a comment\051 terminates a multi-line statement.) 72 490.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+(2.1.7) 72 465 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Indentation) 117 465 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.23 (Leading whitespace \050spaces and tabs\051 at the beginning of a logical line is used to compute the indentation) 72 445.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(level of the line, which in turn is used to determine the grouping of statements.) 72 432.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.26 (First, tabs are replaced \050from left to right\051 by one to eight spaces such that the total number of characters up) 72 407.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.29 (to there is a multiple of eight \050this is intended to be the same rule as used by UNIX\051. The total number of) 72 394.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.24 (spaces preceding the first non-blank character then determines the line\325s indentation. Indentation cannot be) 72 381.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.15 (split over multiple physical lines using backslashes; the whitespace up to the first backslash determines the) 72 368.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(indentation.) 72 355.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.23 (A formfeed character may be present at the start of the line; formfeed characters occurring elsewhere in the) 72 330.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(leading whitespace have an undefined effect \050for instance, they may reset the space count to zero\051.) 72 317.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.06 (The indentation levels of consecutive lines are used to generate INDENT and DEDENT tokens, using a) 72 292.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(stack, as follows.) 72 279.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.03 (Before the first line of the file is read, a single zero is pushed on the stack; this will never be popped off) 72 254.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.31 (again. The numbers pushed on the stack will always be strictly increasing from bottom to top. At the begin-) 72 241.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.09 (ning of each logical line, the line\325s indentation level is compared to the top of the stack. If it is equal, noth-) 72 228.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.04 (ing happens. If it is larger, it is pushed on the stack, and one INDENT token is generated. If it is smaller, it) 72 215.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+3 F
+0.01 (must) 72 202.67 P
+1 F
+0.01 ( be one of the numbers occurring on the stack; all numbers on the stack that are larger are popped off,) 92.78 202.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.09 (and for each number popped off a DEDENT token is generated. At the end of the file, a DEDENT token is) 72 189.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(generated for each number remaining on the stack that is larger than zero.) 72 176.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Here is an example of a correctly \050though confusingly\051 indented piece of Python code:) 72 157.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(def perm\050l\051:) 72 139.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(        # Compute the list of all permutations of l) 72 127.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(    if len\050l\051 <= 1:) 72 115.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(                  return [l]) 72 103.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(    r = []) 72 91.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(    for i in range\050len\050l\051\051:) 72 79.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "4" 10
+%%Page: "5" 11
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(5) 535 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Lexical analysis) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(             s = l[:i] + l[i+1:]) 99 713.33 T
+(             p = perm\050s\051) 99 701.33 T
+(             for x in p:) 99 689.33 T
+(              r.append\050l[i:i+1] + x\051) 99 677.33 T
+(    return r) 99 665.33 T
+1 11 Q
+(The following example shows various indentation errors:) 99 640.67 T
+2 10 Q
+(     def perm\050l\051:                       # error: first line indented) 99 622.33 T
+(    for i in range\050len\050l\051\051:             # error: not indented) 99 610.33 T
+(        s = l[:i] + l[i+1:]) 99 598.33 T
+(            p = perm\050l[:i] + l[i+1:]\051   # error: unexpected indent) 99 586.33 T
+(            for x in p:) 99 574.33 T
+(                    r.append\050l[i:i+1] + x\051) 99 562.33 T
+(                return r                # error: inconsistent dedent) 99 550.33 T
+1 11 Q
+-0.49 (\050Actually, the first three errors are detected by the parser; only the last error is found by the lexical an-) 99 525.67 P
+(alyzer \321 the indentation of) 99 512.67 T
+2 F
+(return r) 222.73 512.67 T
+1 F
+( does not match a level popped off the stack.\051) 275.53 512.67 T
+0 12 Q
+(2.1.8) 99 487 T
+(Whitespace between tokens) 144 487 T
+1 11 Q
+-0.06 (Except at the beginning of a logical line or in string literals, the whitespace characters space, tab and) 99 461.67 P
+0.09 (formfeed can be used interchangeably to separate tokens. Whitespace is needed between two tokens) 99 448.67 P
+0.12 (only if their concatenation could otherwise be interpreted as a different token \050e.g.,) 99 435.67 P
+2 F
+0.29 (ab) 467.77 435.67 P
+1 F
+0.12 ( is one token,) 480.97 435.67 P
+(but) 99 422.67 T
+2 F
+(a) 115.81 422.67 T
+(b) 125.16 422.67 T
+1 F
+( is two tokens\051.) 131.76 422.67 T
+0 14 Q
+(2.2) 99 395.67 T
+(Other tokens) 135 395.67 T
+1 11 Q
+0.93 (Besides NEWLINE, INDENT and DEDENT, the following categories of tokens exist:) 99 370.67 P
+3 F
+0.93 (identifiers) 492.63 370.67 P
+1 F
+0.93 (,) 537.25 370.67 P
+3 F
+-0.24 (keywords) 99 357.67 P
+1 F
+-0.24 (,) 140.55 357.67 P
+3 F
+-0.24 (literals) 145.81 357.67 P
+1 F
+-0.24 (,) 176.99 357.67 P
+3 F
+-0.24 (operators) 182.25 357.67 P
+1 F
+-0.24 (, and) 225.03 357.67 P
+3 F
+-0.24 (delimiters) 248.69 357.67 P
+1 F
+-0.24 (. Whitespace characters \050other than line terminators, dis-) 292.69 357.67 P
+-0.3 (cussed earlier\051 are not tokens, but serve to delimit tokens. Where ambiguity exists, a token comprises) 99 344.67 P
+(the longest possible string that forms a legal token when read from left to right.) 99 331.67 T
+0 14 Q
+(2.3) 99 304.67 T
+(Identifiers and keywords) 135 304.67 T
+1 11 Q
+(Identifiers \050also referred to as) 99 279.67 T
+3 F
+(names) 231.87 279.67 T
+1 F
+(\051 are described by the following lexical definitions:) 259.97 279.67 T
+2 10 Q
+(identifier:     \050letter|"_"\051 \050letter|digit|"_"\051*) 99 261.33 T
+(letter:         lowercase | uppercase) 99 249.33 T
+(lowercase:      "a"..."z") 99 237.33 T
+(uppercase:      "A"..."Z") 99 225.33 T
+(digit:          "0"..."9") 99 213.33 T
+1 11 Q
+(Identifiers are unlimited in length. Case is significant.) 99 188.67 T
+0 12 Q
+(2.3.1) 99 163 T
+(Keywords) 144 163 T
+1 11 Q
+-0.54 (The following identifiers are used as reserved words, or) 99 143.67 P
+3 F
+-0.54 (keywords) 342.17 143.67 P
+1 F
+-0.54 ( of the language, and cannot be used) 383.72 143.67 P
+(as ordinary identifiers. They must be spelled exactly as written here:) 99 130.67 T
+2 10 Q
+(and        elif       global     not        try) 99 112.33 T
+(break      else       if         or         while) 99 100.33 T
+(class      except     import     pass) 99 88.33 T
+(continue   finally    in         print) 99 76.33 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "5" 11
+%%Page: "6" 12
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(6) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(def        for        is         raise) 72 713.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(del        from       lambda     return) 72 701.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+(2.3.2) 72 676 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Reserved classes of identifiers) 117 676 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(Certain classes of identifiers \050besides keywords\051 have special meanings. These are:) 72 650 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\050XXX need section references here.\051) 72 502.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(2.4) 72 475.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Literals) 108 475.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(Literals are notations for constant values of some built-in types) 72 450.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+(2.4.1) 72 425 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(String literals) 117 425 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(String literals are described by the following lexical definitions:) 72 405.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(stringliteral:   shortstring | longstring) 72 387.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(shortstring:     "\325" shortstringitem* "\325" | \325"\325 shortstringitem* \325"\325) 72 375.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(longstring:      "\325\325\325" longstringitem* "\325\325\325" | \325"""\325 longstringitem* \325"""\325) 72 363.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(shortstringitem: shortstringchar | escapeseq) 72 351.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(longstringitem:  longstringchar | escapeseq) 72 339.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(shortstringchar: <any ASCII character except "\134" or newline or the quote>) 72 327.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(longstringchar:  <any ASCII character except "\134">) 72 315.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(escapeseq:       "\134" <any ASCII character>) 72 303.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.21 (In plain English: String literals can be enclosed in single quotes \050\325\051 or double quotes \050"\051. They can also be) 72 278.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.33 (enclosed in groups of three single or double quotes \050these are generally referred to as) 72 265.67 P
+3 F
+-0.33 (triple-quoted strings) 443.77 265.67 P
+1 F
+-0.33 (\051.) 533.59 265.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.39 (The backslash \050\134\051 character is used to escape characters that otherwise have a special meaning, such as new-) 72 252.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(line, backslash itself, or the quote character.) 72 239.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.32 (In \322long strings\323 \050strings surrounded by sets of three quotes\051, unescaped newlines and quotes are allowed) 72 214.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.03 (\050and are retained\051, except that three unescaped quotes in a row terminate the string. \050A \322quote\323 is the char-) 72 201.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(acter used to open the string, i.e. either) 72 188.67 T
+2 F
+(\325) 245.22 188.67 T
+1 F
+( or) 251.82 188.67 T
+2 F
+(") 266.48 188.67 T
+1 F
+(.\051) 273.08 188.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 12 Q
+(T) 132.71 626 T
+(able 1: Special Meanings of Identi\336ers) 139.61 626 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(F) 95.09 600 T
+(orm) 101.58 600 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Meaning) 248.67 600 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(  _*) 78 577.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 12 Q
+(Not imported by) 150 576 T
+2 F
+(from) 232.33 576 T
+3 F
+( module) 261.13 576 T
+2 F
+(import) 302.46 576 T
+(*) 348.66 576 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(  __*__) 78 554 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(System-de\336ned name) 150 554 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(  __*) 78 532 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Class-pri) 150 532 T
+(v) 193.03 532 T
+(ate name mangling) 198.73 532 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+72 615.75 72 524.25 2 L
+V
+0.5 H
+0 Z
+N
+144 616.25 144 523.75 2 L
+V
+N
+396 615.75 396 524.25 2 L
+V
+N
+71.75 616 396.25 616 2 L
+V
+N
+72.25 591.25 395.75 591.25 2 L
+V
+N
+72.25 588.75 395.75 588.75 2 L
+V
+N
+71.75 568 396.25 568 2 L
+V
+N
+71.75 546 396.25 546 2 L
+V
+N
+71.75 524 396.25 524 2 L
+V
+N
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "6" 12
+%%Page: "7" 13
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(7) 535 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Lexical analysis) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.41 0.03 (Escape sequences in strings are interpreted according to rules similar to those used by Standard C.) 99 712.67 B
+(The recognized escape sequences are:) 99 699.67 T
+-0.24 (In strict compatibility with Standard C, up to three octal digits are accepted, but an unlimited number) 99 332.67 P
+-0.12 (of hex digits is taken to be part of the hex escape \050and then the lower 8 bits of the resulting hex num-) 99 319.67 P
+(ber are used in all current implementations...\051.) 99 306.67 T
+-0.21 (Unlike Standard C, all unrecognized escape sequences are left in the string unchanged, i.e.,) 99 281.67 P
+3 F
+-0.21 (the back-) 499.59 281.67 P
+-0.39 (slash is left in the string.) 99 268.67 P
+1 F
+-0.39 ( \050This behavior is useful when debugging: if an escape sequence is mistyped,) 205.24 268.67 P
+0.41 0 (the resulting output is more easily recognized as broken. It also helps a great deal for string literals) 99 255.67 B
+-0.17 (used as regular expressions or otherwise passed to other modules that do their own escape handling.\051) 99 242.67 P
+0 F
+(2.4.1.1) 99 220.67 T
+(String literal concatenation) 144 220.67 T
+1 F
+0.21 (Multiple adjacent string literals \050delimited by whitespace\051, possibly using different quoting conven-) 99 195.67 P
+-0.02 (tions, are allowed, and their meaning is the same as their concatenation. Thus,) 99 182.67 P
+2 F
+-0.05 ("hello") 444.87 182.67 P
+-0.05 (\325world\325) 493.8 182.67 P
+1 F
+0.41 0.12 (is equivalent to) 99 169.67 B
+2 F
+0.99 0.12 ("helloworld") 172.31 169.67 B
+1 F
+0.41 0.12 (. This feature can be used to reduce the number of backslashes) 252.99 169.67 B
+0.41 0.15 (needed, to split long strings conveniently across long lines, or even to add comments to parts of) 99 156.67 B
+(strings, for example:) 99 143.67 T
+2 10 Q
+(regex.compile\050"[A-Za-z_]"       # letter or underscore) 99 125.33 T
+(              "[A-Za-z0-9_]*"   # letter, digit or underscore) 99 113.33 T
+(             \051) 99 101.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 12 Q
+(T) 188.55 676 T
+(able 2: Escape Sequences) 195.45 676 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Escape Sequence) 109.27 650 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Meaning) 286.92 650 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134) 105 626 T
+3 F
+(ne) 112.2 626 T
+(wline) 123.35 626 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( Ignored) 208.5 626 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134\134) 105 604 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( Backslash \050) 208.5 604 T
+2 F
+(\134) 267.16 604 T
+1 F
+(\051) 274.36 604 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134\325) 105 582 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( Single quote \050) 208.5 582 T
+2 F
+(\325) 278.83 582 T
+1 F
+(\051) 286.03 582 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134") 105 560 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( Double quote \050) 208.5 560 T
+2 F
+(") 283.49 560 T
+1 F
+(\051) 290.69 560 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134a) 105 538 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII Bell \050BEL\051) 208.5 538 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134b) 105 516 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII Backspace \050BS\051) 208.5 516 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134f) 105 494 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII F) 208.5 494 T
+(ormfeed \050FF\051) 252.32 494 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134n) 105 472 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII Linefeed \050LF\051) 208.5 472 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134r) 105 450 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII Carriage Return \050CR\051) 208.5 450 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134t) 105 428 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII Horizontal T) 208.5 428 T
+(ab \050T) 306.53 428 T
+(AB\051) 331.07 428 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134v) 105 406 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII V) 208.5 406 T
+(ertical T) 253.16 406 T
+(ab \050VT\051) 292.52 406 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134) 105 384 T
+3 F
+(ooo) 112.2 384 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII character with octal v) 208.5 384 T
+(alue) 349.16 384 T
+3 F
+(ooo) 372.16 384 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(\134x) 105 362 T
+3 F
+(xx...) 119.4 362 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( ASCII character with he) 208.5 362 T
+(x v) 328.28 362 T
+(alue) 342.98 362 T
+3 F
+(xx...) 365.98 362 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+99 665.75 99 354.25 2 L
+V
+0.5 H
+0 Z
+N
+202.5 666.25 202.5 353.75 2 L
+V
+N
+414 665.75 414 354.25 2 L
+V
+N
+98.75 666 414.25 666 2 L
+V
+N
+99.25 641.25 413.75 641.25 2 L
+V
+N
+99.25 638.75 413.75 638.75 2 L
+V
+N
+98.75 618 414.25 618 2 L
+V
+N
+98.75 596 414.25 596 2 L
+V
+N
+98.75 574 414.25 574 2 L
+V
+N
+98.75 552 414.25 552 2 L
+V
+N
+98.75 530 414.25 530 2 L
+V
+N
+98.75 508 414.25 508 2 L
+V
+N
+98.75 486 414.25 486 2 L
+V
+N
+98.75 464 414.25 464 2 L
+V
+N
+98.75 442 414.25 442 2 L
+V
+N
+98.75 420 414.25 420 2 L
+V
+N
+98.75 398 414.25 398 2 L
+V
+N
+98.75 376 414.25 376 2 L
+V
+N
+98.75 354 414.25 354 2 L
+V
+N
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "7" 13
+%%Page: "8" 14
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(8) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.32 (Note that this feature is defined at the syntactical level, but implemented at compile time. The \324+\325 op-) 76.5 712.67 P
+(erator must be used to concatenate string expressions at run time.) 76.5 699.67 T
+0 12 Q
+(2.4.2) 76.5 674 T
+(Numeric literals) 121.5 674 T
+1 11 Q
+0.97 (There are four types of numeric literals: plain integers, long integers, floating point numbers, and) 76.5 654.67 P
+(imaginary numbers.) 76.5 641.67 T
+0 F
+(2.4.2.1) 76.5 619.67 T
+(Integer and long integer literals) 121.5 619.67 T
+1 F
+(Integer and long integer literals are described by the following lexical definitions:) 76.5 594.67 T
+2 10 Q
+(longinteger:    integer \050"l"|"L"\051) 76.5 576.33 T
+(integer:        decimalinteger | octinteger | hexinteger) 76.5 564.33 T
+(decimalinteger: nonzerodigit digit* | "0") 76.5 552.33 T
+(octinteger:     "0" octdigit+) 76.5 540.33 T
+(hexinteger:     "0" \050"x"|"X"\051 hexdigit+) 76.5 528.33 T
+(nonzerodigit:   "1"..."9") 76.5 516.33 T
+(octdigit:       "0"..."7") 76.5 504.33 T
+(hexdigit:       digit|"a"..."f"|"A"..."F") 76.5 492.33 T
+1 11 Q
+-0.03 (Although both lower case \324l\325 and upper case \324L\325 are allowed as suffix for long integers, it is strongly) 76.5 467.67 P
+(recommended to always use \324L\325, since the letter \324l\325 looks too much like the digit \3241\325.) 76.5 454.67 T
+-0.24 (Plain integer decimal literals must be at most 2147483647 \050i.e., the largest positive integer, using 32-) 76.5 429.67 P
+-0.23 (bit arithmetic\051. Plain octal and hexadecimal literals may be as large as 4294967295, but values larger) 76.5 416.67 P
+-0.05 (than 2147483647 are converted to a negative value by subtracting 4294967296. There is no limit for) 76.5 403.67 P
+(long integer literals apart from what can be stored in available memory.) 76.5 390.67 T
+(Some examples of plain and long integer literals:) 76.5 365.67 T
+2 10 Q
+(7     2147483647                        0177    0x80000000) 76.5 347.33 T
+(3L    79228162514264337593543950336L    0377L   0x100000000L) 76.5 335.33 T
+0 11 Q
+(2.4.2.2) 76.5 313.67 T
+(Floating point literals) 121.5 313.67 T
+1 F
+(Floating point literals are described by the following lexical definitions:) 76.5 288.67 T
+2 10 Q
+(floatnumber:    pointfloat | exponentfloat) 76.5 270.33 T
+(pointfloat:     [intpart] fraction | intpart ".") 76.5 258.33 T
+(exponentfloat:  \050intpart | pointfloat\051 exponent) 76.5 246.33 T
+(intpart:        digit+) 76.5 234.33 T
+(fraction:       "." digit+) 76.5 222.33 T
+(exponent:       \050"e"|"E"\051 ["+"|"-"] digit+) 76.5 210.33 T
+1 11 Q
+-0.39 (The allowed range of floating point literals is implementation-dependent.  Some examples of floating) 76.5 185.67 P
+(point literals:) 76.5 172.67 T
+2 10 Q
+(3.14    10.     .001    1e100   3.14e-10) 76.5 154.33 T
+0 11 Q
+(2.4.2.3) 76.5 132.67 T
+(Imaginary literals) 121.5 132.67 T
+1 F
+(Imaginary literals are described by the following lexical definitions:) 76.5 107.67 T
+2 10 Q
+(imagnumber:     \050floatnumber | intpart\051 \050"j"|"J"\051) 76.5 89.33 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "8" 14
+%%Page: "9" 15
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(9) 535 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Lexical analysis) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.3 (An imaginary literals yields a complex number with a real part of 0.0. Complex numbers are repre-) 99 712.67 P
+0.28 (sented as a pair of floating point numbers and have the same restrictions on their range. To create a) 99 699.67 P
+-0.19 (complex number with a nonzero real part, add a floating point number to it, e.g.) 99 686.67 P
+2 F
+-0.46 (\0503+4j\051.) 449.58 686.67 P
+1 F
+-0.19 ( Some ex-) 495.78 686.67 P
+(amples of imaginary literals:) 99 673.67 T
+2 10 Q
+(3.14j   10.j    10 j    .001j   1e100j  3.14e-10j) 99 655.33 T
+1 11 Q
+-0.05 (Note that numeric literals do not include a sign; a phrase like) 99 630.67 P
+2 F
+-0.12 (-1) 369.1 630.67 P
+1 F
+-0.05 ( is actually an expression composed) 382.3 630.67 P
+(of the unary operator \324) 99 617.67 T
+2 F
+(-) 197.97 617.67 T
+1 F
+(\325 and the literal) 204.57 617.67 T
+2 F
+(1) 274.22 617.67 T
+1 F
+(.) 280.82 617.67 T
+0 14 Q
+(2.5) 99 590.67 T
+(Operators) 135 590.67 T
+1 11 Q
+(The following tokens are operators:) 99 565.67 T
+2 10 Q
+(+       -       *       **      /       %) 99 547.33 T
+(<<      >>      &       |       ^       ~) 99 535.33 T
+(<       >       <=      >=      ==      !=      <>) 99 523.33 T
+1 11 Q
+-0.06 (The comparison operators) 99 498.67 P
+2 F
+-0.14 (<>) 216.44 498.67 P
+1 F
+-0.06 ( and) 229.64 498.67 P
+2 F
+-0.14 (!=) 250.9 498.67 P
+1 F
+-0.06 ( are alternate spellings of the same operator; != is the preferred) 264.1 498.67 P
+(spelling,  <> is obsolescent.) 99 485.67 T
+0 14 Q
+(2.6) 99 458.67 T
+(Delimiters) 135 458.67 T
+1 11 Q
+(The following tokens serve as delimiters in the grammar:) 99 433.67 T
+2 10 Q
+(\050       \051       [       ]       {       }) 99 415.33 T
+(,       :       .       \324       =       ;) 99 403.33 T
+1 11 Q
+0.05 (The period can also occur in floating-point and imaginary literals. A sequence of three periods has a) 99 378.67 P
+(special meaning as ellipses in slices.) 99 365.67 T
+0.41 0.01 (The following printing ASCII characters have special meaning as part of other tokens or are other-) 99 340.67 B
+(wise significant to the lexical analyzer:) 99 327.67 T
+2 10 Q
+(\325       "       #       \134) 99 309.33 T
+1 11 Q
+0.19 (The following printing ASCII characters are not used in Python. Their occurrence outside string lit-) 99 284.67 P
+(erals and comments is an unconditional error:) 99 271.67 T
+2 10 Q
+(@       $       ?) 99 253.33 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "9" 15
+%%Page: "10" 16
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(10) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "10" 16
+%%Page: "11" 17
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(11) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Data model) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 16 Q
+(C) 99 709.33 T
+0 12.8 Q
+(HAPTER) 110.55 709.33 T
+0 16 Q
+(3:) 167.62 709.33 T
+(D) 198 709.33 T
+0 12.8 Q
+(ATA) 209.55 709.33 T
+(MODEL) 240.3 709.33 T
+0 14 Q
+(3.1) 99 670.67 T
+(Objects, values and types) 135 670.67 T
+3 11 Q
+0.32 (Objects) 99 645.67 P
+1 F
+0.32 ( are Python\325s abstraction for data. All data in a Python program is represented by objects or) 132.6 645.67 P
+0.1 (by relations between objects. \050In conformance to Von Neumann\325s model of a \322stored program com-) 99 632.67 P
+(puter\323, code is also represented by objects.\051) 99 619.67 T
+0.13 (Every object has an identity, a type and a value. An object\325s) 99 594.67 P
+3 F
+0.13 (identity) 367.55 594.67 P
+1 F
+0.13 ( never changes once it has been) 400.55 594.67 P
+-0.28 (created; you may think of it as the object\325s address in memory. The \324) 99 581.67 P
+2 F
+-0.67 (is) 398.41 581.67 P
+1 F
+-0.28 (\325 operator compares the iden-) 411.61 581.67 P
+0.15 (tity of two objects; the \324) 99 568.67 P
+2 F
+0.37 (id\050\051) 205.18 568.67 P
+1 F
+0.15 (\325 function returns an integer representing its identity \050currently imple-) 231.58 568.67 P
+0.41 0.06 (mented as its address\051. An object\325s) 99 555.67 B
+3 F
+0.41 0.06 (type) 259.84 555.67 B
+1 F
+0.41 0.06 ( is also unchangeable. It determines the operations that an) 278.42 555.67 B
+0.01 (object supports \050e.g. \322does it have a length?\323\051 and also defines the possible values for objects of that) 99 542.67 P
+0.19 (type. The \324) 99 529.67 P
+2 F
+0.46 (type\050\051) 147.34 529.67 P
+1 F
+0.19 (\325 function returns an object\325s type \050which is an object itself\051. The) 186.94 529.67 P
+3 F
+0.19 (value) 477.91 529.67 P
+1 F
+0.19 ( of some) 501.74 529.67 P
+0.36 (objects can change. The \324) 99 516.67 P
+2 F
+0.85 (==) 212.52 516.67 P
+1 F
+0.36 (\325 operator compares the value of two objects. Objects whose value can) 225.72 516.67 P
+0.11 (change are said to be) 99 503.67 P
+3 F
+0.11 (mutable) 194.54 503.67 P
+1 F
+0.11 (; objects whose value is unchangeable once they are created are called) 229.98 503.67 P
+3 F
+0.41 0.01 (immutable) 99 490.67 B
+1 F
+0.41 0.01 (. An object\325s \050im\051mutability is determined by its type; for instance, numbers, strings and) 145.49 490.67 B
+(tuples are immutable, while dictionaries and lists are mutable.) 99 477.67 T
+0.41 0.05 (Objects are never explicitly destroyed; however, when they become unreachable they may be gar-) 99 452.67 B
+-0.25 (bage-collected. An implementation is allowed to postpone garbage collection or omit it altogether \321) 99 439.67 P
+-0.18 (it is a matter of implementation quality how garbage collection is implemented, as long as no objects) 99 426.67 P
+0.27 (are collected that are still reachable. \050Implementation note: the current implementation uses a refer-) 99 413.67 P
+0.41 0.05 (ence-counting scheme which collects most objects as soon as they become unreachable, but never) 99 400.67 B
+(collects garbage containing circular references.\051) 99 387.67 T
+0.09 (Note that the use of the implementation\325s tracing or debugging facilities may keep objects alive that) 99 362.67 P
+-0.32 (would normally be collectable. Also note that catching an exception with a \324) 99 349.67 P
+2 F
+-0.77 (try...except) 430.88 349.67 P
+1 F
+-0.32 (\325 state-) 510.08 349.67 P
+(ment may keep objects alive.) 99 336.67 T
+0.41 0 (Some objects contain references to \322external\323 resources such as open files or windows. It is under-) 99 311.67 B
+-0.38 (stood that these resources are freed when the object is garbage-collected, but since garbage collection) 99 298.67 P
+-0.5 (is not guaranteed to happen, such objects also provide an explicit way to release the external resource,) 99 285.67 P
+-0.42 (usually a) 99 272.67 P
+2 F
+-1 (close\050\051) 140.33 272.67 P
+1 F
+-0.42 ( method. Programs are strongly recommended to always explicitly close such ob-) 186.53 272.67 P
+(jects. The \324) 99 259.67 T
+2 F
+(try...finally) 148.18 259.67 T
+1 F
+(\325 statement provides a convenient way to do this.) 233.98 259.67 T
+-0.25 (Some objects contain references to other objects; these are called) 99 234.67 P
+3 F
+-0.25 (containers) 385.54 234.67 P
+1 F
+-0.25 (. Examples of containers) 431.98 234.67 P
+0.26 (are tuples, lists and dictionaries. The references are part of a container\325s value. In most cases, when) 99 221.67 P
+-0.42 (we talk about the value of a container, we imply the values, not the identities of the contained objects;) 99 208.67 P
+-0.32 (however, when we talk about the \050im\051mutability of a container, only the identities of the immediately) 99 195.67 P
+0.41 0.01 (contained objects are implied. So, if an immutable container \050like a tuple\051 contains a reference to a) 99 182.67 B
+(mutable object, its value changes if that mutable object is changed.) 99 169.67 T
+0.03 (Types affect almost all aspects of object behavior. Even the importance of object identity is affected) 99 144.67 P
+-0.05 (in some sense: for immutable types, operations that compute new values may actually return a refer-) 99 131.67 P
+0.41 0.08 (ence to any existing object with the same type and value, while for mutable objects this is not al-) 99 118.67 B
+-0.36 (lowed. E.g. after \324\324) 99 105.67 P
+2 F
+-0.86 (a = 1; b =) 181.01 105.67 P
+1 F
+-0.36 (1\325\325,) 249.3 105.67 P
+2 F
+-0.86 (a) 267.26 105.67 P
+1 F
+-0.36 ( and) 273.86 105.67 P
+2 F
+-0.86 (b) 294.53 105.67 P
+1 F
+-0.36 ( may or may not refer to the same object with the value) 301.13 105.67 P
+-0.1 (one, depending on the implementation, but after \324\324) 99 92.67 P
+2 F
+-0.24 (c = []; d = []) 319.79 92.67 P
+1 F
+-0.1 (\325\325,) 410.99 92.67 P
+2 F
+-0.24 (c) 423.71 92.67 P
+1 F
+-0.1 ( and) 430.31 92.67 P
+2 F
+-0.24 (d) 451.5 92.67 P
+1 F
+-0.1 (are guaranteed to) 464.45 92.67 P
+0.41 0.03 (refer to two different, unique, newly created empty lists. \050Note that \324\324) 99 79.67 B
+2 F
+0.99 0.03 (c = d = []) 410.5 79.67 B
+1 F
+0.41 0.03 (\325\325 assigns the) 480.75 79.67 B
+(same object to both) 99 66.67 T
+2 F
+(c) 187.6 66.67 T
+1 F
+( and) 194.21 66.67 T
+2 F
+(d) 215.59 66.67 T
+1 F
+(.\051) 222.19 66.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "11" 17
+%%Page: "12" 18
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(12) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(3.2) 76.5 710.67 T
+(The standard type hierarchy) 112.5 710.67 T
+1 11 Q
+0.12 (Below is a list of the types that are built into Python. Extension modules written in C can define ad-) 76.5 685.67 P
+0.01 (ditional types. Future versions of Python may add types to the type hierarchy \050e.g. rational numbers,) 76.5 672.67 P
+(efficiently stored arrays of integers, etc.\051.) 76.5 659.67 T
+1.02 (Some of the type descriptions below contain a paragraph listing \324special attributes\325. These are at-) 76.5 640.67 P
+0.03 (tributes that provide access to the implementation and are not intended for general use. Their defini-) 76.5 627.67 P
+0.87 (tion may change in the future. There are also some \324generic\325 special attributes, not listed with the) 76.5 614.67 P
+0.38 (individual objects:) 76.5 601.67 P
+2 F
+0.92 (__methods__) 161.6 601.67 P
+1 F
+0.38 (is a list of the method names of a built-in object, if it has any;) 241.73 601.67 P
+2 F
+(__members__) 76.5 588.67 T
+1 F
+( is a list of the data attribute names of a built-in object, if it has any.) 149.1 588.67 T
+4 F
+(None) 76.5 569.67 T
+1 F
+0.12 (This type has a single value. There is a single object with this value. This object is accessed) 112.5 569.67 P
+0.49 (through the built-in name) 112.5 556.67 P
+2 F
+1.17 (None) 229.34 556.67 P
+1 F
+0.49 (. It is used to signify the absence of a value in many situa-) 255.74 556.67 P
+-0.03 (tions, e.g. it is returned from functions that don\325t explicitly return anything. Its truth value is) 112.5 543.67 P
+(false.) 112.5 530.67 T
+4 F
+(Ellipsis) 76.5 511.67 T
+1 F
+0.06 (This type has a single value. There is a single object with this value. This object is accessed) 113.49 511.67 P
+0.04 (through the built-in name) 112.5 498.67 P
+2 F
+0.09 (Ellipsis) 227.53 498.67 P
+1 F
+0.04 (. It is used to indicate the presence of the \324\324...\325\325 syntax) 280.33 498.67 P
+(in a slice. Its truth value is true.) 112.5 485.67 T
+4 F
+(Numbers) 76.5 466.67 T
+1 F
+0.6 (These are created by numeric literals and returned as results by arithmetic operators and) 122.63 466.67 P
+-0.01 (arithmetic built-in functions. Numeric objects are immutable; once created their value never) 112.5 453.67 P
+-0.52 (changes. Python numbers are of course strongly related to mathematical numbers, but subject) 112.5 440.67 P
+(to the limitations of numerical representation in computers.) 112.5 427.67 T
+(Python distinguishes between integers and floating point numbers:) 112.5 410.67 T
+4 F
+(Integers) 112.5 391.67 T
+1 F
+(These represent elements from the mathematical set of whole numbers) 153.74 391.67 T
+(There are two types of integers:) 130.5 374.67 T
+4 F
+(Plain integers) 130.5 355.67 T
+1 F
+-0.47 (These represent numbers in the range -2147483648 through 2147483647.) 197.72 355.67 P
+0.61 (\050The range may be larger on machines with a larger natural word size, but not) 166.5 342.67 P
+0.33 (smaller.\051 When the result of an operation falls outside this range, the exception) 166.5 329.67 P
+2 F
+-0.33 (OverflowError) 166.5 316.67 P
+1 F
+-0.14 ( is raised. For the purpose of shift and mask operations, inte-) 252.3 316.67 P
+0.69 0.01 (gers are assumed to have a binary, 2\325s complement notation using 32 or more) 166.5 303.67 B
+0.18 (bits, and hiding no bits from the user \050i.e., all 4294967296 different bit patterns) 166.5 290.67 P
+(correspond to different values\051.) 166.5 277.67 T
+4 F
+(Long integers) 130.5 258.67 T
+1 F
+0.05 (These represent numbers in an unlimited range, subject to available \050vir-) 197.72 258.67 P
+-0.24 (tual\051 memory only. For the purpose of shift and mask operations, a binary repre-) 166.5 245.67 P
+0.69 0 (sentation is assumed, and negative numbers are represented in a variant of 2\325s) 166.5 232.67 B
+0.32 (complement which gives the illusion of an infinite string of sign bits extending) 166.5 219.67 P
+(to the left.) 166.5 206.67 T
+0.02 (The rules for integer representation are intended to give the most meaningful interpreta-) 130.5 189.67 P
+-0.48 (tion of shift and mask operations involving negative integers and the least surprises when) 130.5 176.67 P
+-0.62 (switching between the plain and long integer domains. For any operation except left shift,) 130.5 163.67 P
+-0.08 (if it yields a result in the plain integer domain without causing overflow, it will yield the) 130.5 150.67 P
+(same result in the long integer domain or when using mixed operands.) 130.5 137.67 T
+4 F
+(Floating point numbers) 112.5 118.67 T
+1 F
+-0.98 (These represent machine-level double precision floating point num-) 225.88 118.67 P
+-0.22 (bers. You are at the mercy of the underlying machine architecture and C implementation) 130.5 105.67 P
+0.4 (for the accepted range and handling of overflow. Python does not support single-preci-) 130.5 92.67 P
+0.23 (sion floating point numbers; the savings in CPU and memory usage that are usually the) 130.5 79.67 P
+0.07 (reason for using these is dwarfed by the overhead of using objects in Python, so there is) 130.5 66.67 P
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "12" 18
+%%Page: "13" 19
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(13) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Data model) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(no reason to complicate the language with two kinds of floating point numbers.) 153 712.67 T
+4 F
+(Complex numbers) 135 693.67 T
+1 F
+-0.44 (These represent complex numbers as a pair of machine-level double pre-) 224.22 693.67 P
+-0.43 (cision floating point numbers. The same caveats apply as for floating point numbers. The) 153 680.67 P
+0.16 (real and imaginary value of a complex number) 153 667.67 P
+2 F
+0.38 (z) 362.6 667.67 P
+1 F
+0.16 ( can be retrieved through the attributes) 369.2 667.67 P
+2 F
+(z.real) 153 654.67 T
+1 F
+( and) 192.6 654.67 T
+2 F
+(z.imag) 213.98 654.67 T
+1 F
+(.) 253.58 654.67 T
+4 F
+(Sequences) 99 635.67 T
+1 F
+1.51 (These represent finite ordered sets indexed by natural numbers. The built-in function) 150.03 635.67 P
+2 F
+0.82 (len\050\051) 135 622.67 P
+1 F
+0.34 ( returns the number of items of a sequence. When the length of a sequence is) 168 622.67 P
+2 F
+0.82 (n) 514.11 622.67 P
+1 F
+0.34 (, the) 520.71 622.67 P
+(index set contains the numbers 0, 1, ...,) 135 609.67 T
+2 F
+(n) 309.15 609.67 T
+1 F
+(. Item) 315.75 609.67 T
+2 F
+(i) 344.17 609.67 T
+1 F
+( of sequence) 350.77 609.67 T
+2 F
+(a) 408.49 609.67 T
+1 F
+( is selected by) 415.09 609.67 T
+2 F
+(a[i]) 479.86 609.67 T
+1 F
+(.) 506.26 609.67 T
+4.29 (Sequences also support slicing:) 135 592.67 P
+2 F
+10.28 (a[i:j]) 292.69 592.67 P
+1 F
+4.29 ( selects all items with index) 332.29 592.67 P
+2 F
+10.28 (k) 482.67 592.67 P
+1 F
+4.29 ( such that) 489.27 592.67 P
+2 F
+1.18 (i) 135 579.67 P
+1.18 (<=) 148.2 579.67 P
+1.18 (k) 168 579.67 P
+1.18 (<) 181.2 579.67 P
+1.18 (j) 194.4 579.67 P
+1 F
+0.49 (. When used as an expression, a slice is a sequence of the same type \321 this) 201 579.67 P
+(implies that the index set is renumbered so that it starts at 0 again.) 135 566.67 T
+(Sequences are distinguished according to their mutability:) 135 549.67 T
+4 F
+(Immutable sequences) 135 530.67 T
+1 F
+-0.82 (An object of an immutable sequence type cannot change once it is cre-) 238.88 530.67 P
+-0.16 (ated. \050If the object contains references to other objects, these other objects may be muta-) 153 517.67 P
+2.87 (ble and may be changed; however the array of objects directly referenced by an) 153 504.67 P
+(immutable object cannot change.\051) 153 491.67 T
+(The following types are immutable sequences:) 153 474.67 T
+4 F
+(Strings) 153 455.67 T
+1 F
+0.13 (The items of a string are characters. There is no separate character type; a char-) 189 455.67 P
+0.31 (acter is represented by a string of one item. Characters represent \050at least\051 8-bit) 189 442.67 P
+-0.49 (bytes. The built-in functions) 189 429.67 P
+2 F
+-1.18 (chr\050\051) 314.45 429.67 P
+1 F
+-0.49 ( and) 347.45 429.67 P
+2 F
+-1.18 (ord\050\051) 367.85 429.67 P
+1 F
+-0.49 ( convert between characters and) 400.85 429.67 P
+0.55 (nonnegative integers representing the byte values. Bytes with the values 0-127) 189 416.67 P
+0.24 (usually represent the corresponding ASCII values, but the interpretation of val-) 189 403.67 P
+0.15 (ues is up to the program. The string data type is also used to represent arrays of) 189 390.67 P
+(bytes, e.g. to hold data read from a file.) 189 377.67 T
+(\050What should be done on systems whose native character set is not ASCII???\051) 189 360.67 T
+4 F
+(Tuples) 153 341.67 T
+1 F
+0.56 (The items of a tuple are arbitrary Python objects. Tuples of two or more items) 189 341.67 P
+-0.21 (are formed by comma-separated lists of expressions. A tuple of one item \050a \324sin-) 189 328.67 P
+0.14 (gleton\325\051 can be formed by affixing a comma to an expression \050an expression by) 189 315.67 P
+0.59 (itself does not create a tuple, since parentheses must be usable for grouping of) 189 302.67 P
+-0.14 (expressions\051. An empty tuple can be formed by enclosing \324nothing\325 in parenthe-) 189 289.67 P
+(ses: \324\324) 189 276.67 T
+2 F
+(\050\051) 215.58 276.67 T
+1 F
+(\325\325.) 228.78 276.67 T
+4 F
+(Mutable sequences) 135 257.67 T
+1 F
+-0.22 (Mutable sequences can be changed after they are created. The subscrip-) 226.66 257.67 P
+-0.14 (tion and slicing notations can be used as the target of assignment and) 153 244.67 P
+2 F
+-0.34 (del) 457.57 244.67 P
+1 F
+-0.14 ( \050delete\051 state-) 477.37 244.67 P
+(ments.) 153 231.67 T
+(There is currently a single mutable sequence type:) 153 214.67 T
+4 F
+(Lists) 153 195.67 T
+1 F
+0.69 0.04 (The items of a list are arbitrary Python objects. Lists are formed by placing a) 189 195.67 B
+0.42 (comma-separated list of expressions in square brackets. \050Note that there are no) 189 182.67 P
+(special cases needed to form lists of length 0 or 1.\051) 189 169.67 T
+-0.52 (The optional module) 153 150.67 P
+2 F
+-1.24 (array) 245.86 150.67 P
+1 F
+-0.52 ( provides an additional example of a mutable sequence type.) 278.86 150.67 P
+4 F
+(Mappings) 99 131.67 T
+1 F
+-0.88 (These represent finite sets of objects indexed by arbitrary index sets. The subscript notation) 148.82 131.67 P
+2 F
+-0.47 (a[k]) 135 118.67 P
+1 F
+-0.2 ( selects the item indexed by) 161.4 118.67 P
+2 F
+-0.47 (k) 284.86 118.67 P
+1 F
+-0.2 ( from the mapping) 291.46 118.67 P
+2 F
+-0.47 (a) 375 118.67 P
+1 F
+-0.2 (; this can be used in expressions and) 381.6 118.67 P
+-0.62 (as the target of assignments or) 135 105.67 P
+2 F
+-1.48 (del) 267.56 105.67 P
+1 F
+-0.62 ( statements. The built-in function) 287.36 105.67 P
+2 F
+-1.48 (len\050\051) 433.39 105.67 P
+1 F
+-0.62 ( returns the num-) 466.39 105.67 P
+(ber of items in a mapping.) 135 92.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "13" 19
+%%Page: "14" 20
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(14) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(There is currently a single intrinsic mapping type:) 112.5 712.67 T
+4 F
+(Dictionaries) 112.5 693.67 T
+1 F
+0.85 (These represent finite sets of objects indexed by nearly arbitrary values. The) 172.08 693.67 P
+0.23 (only types of values not acceptable as keys are values containing lists or dictionaries or) 130.5 680.67 P
+-0.09 (other mutable types that are compared by value rather than by object identity \321 the rea-) 130.5 667.67 P
+0.51 (son being that the efficient implementation of dictionaries requires a key\325s value to re-) 130.5 654.67 P
+3.46 (main constant. Numeric types used for keys obey the normal rules for numeric) 130.5 641.67 P
+0.18 (comparison: if two numbers compare equal \050e.g. 1 and 1.0\051 then they can be used inter-) 130.5 628.67 P
+(changeably to index the same dictionary entry.) 130.5 615.67 T
+-0.29 (Dictionaries are mutable; they are created by the) 130.5 598.67 P
+2 F
+-0.7 ({...}) 344.44 598.67 P
+1 F
+-0.29 (notation. \050See \322Dictionary dis-) 383.34 598.67 P
+(plays\323 on page) 130.5 585.67 T
+(28.\051) 198.62 585.67 T
+0.29 (The optional library modules) 112.5 568.67 P
+2 F
+0.7 (dbm) 244.43 568.67 P
+1 F
+0.29 (,) 264.23 568.67 P
+2 F
+0.7 (gdbm) 270.02 568.67 P
+1 F
+0.29 ( and) 296.42 568.67 P
+2 F
+0.7 (bsddb) 318.38 568.67 P
+1 F
+0.29 ( provide additional examples of map-) 351.38 568.67 P
+(ping types.) 112.5 555.67 T
+4 F
+(Callable types) 76.5 536.67 T
+1 F
+0.22 (These are the types to which the function call operation \050for invocation, See \322Calls\323) 145.56 536.67 P
+(on page) 112.5 523.67 T
+(31.\051 is applied:) 149.77 523.67 T
+4 F
+(User-defined functions) 112.5 504.67 T
+1 F
+0.8 (A user-defined function object is created by a function definition.) 221.88 504.67 P
+(\050See \322Function definitions\323 on page) 130.5 491.67 T
+(48.\051) 291.51 491.67 T
+0.53 (Special read-only attributes:) 130.5 474.67 P
+2 F
+1.27 (func_doc) 258.88 474.67 P
+1 F
+0.53 ( or) 311.68 474.67 P
+2 F
+1.27 (__doc__) 327.41 474.67 P
+1 F
+0.53 ( is the function\325s documentation) 373.61 474.67 P
+1.75 (string, or) 130.5 461.67 P
+2 F
+4.2 (None) 176.47 461.67 P
+1 F
+1.75 ( if unavailable;) 202.87 461.67 P
+2 F
+4.2 (func_name) 276.86 461.67 P
+1 F
+1.75 ( or) 336.26 461.67 P
+2 F
+4.2 (__name__) 354.43 461.67 P
+1 F
+1.75 ( is the function\325s name;) 407.23 461.67 P
+2 F
+2.63 (func_defaults) 130.5 448.67 P
+1 F
+1.1 ( is a tuple containing default argument values for those arguments) 216.3 448.67 P
+0.81 (that have defaults, or) 130.5 435.67 P
+2 F
+1.93 (None) 228.73 435.67 P
+1 F
+0.81 ( if no arguments have a default value;) 255.13 435.67 P
+2 F
+1.93 (func_code) 430.21 435.67 P
+1 F
+0.81 ( is the) 489.61 435.67 P
+0.54 (code object representing the compiled function body;) 130.5 422.67 P
+2 F
+1.29 (func_globals) 371.64 422.67 P
+1 F
+0.54 ( is \050a reference) 450.84 422.67 P
+-0.07 (to\051 the dictionary that holds the function\325s global variables \321 it defines the global name) 130.5 409.67 P
+0.35 (space of the module in which the function was defined. Additional information about a) 130.5 396.67 P
+-0.19 (function\325s definition can be retrieved from its code object; see the description of internal) 130.5 383.67 P
+(types below.) 130.5 370.67 T
+4 F
+(User-defined methods) 112.5 351.67 T
+1 F
+2.17 (A user-defined method object \050a.k.a.) 218.21 351.67 P
+3 F
+2.17 (object closure) 392.77 351.67 P
+1 F
+2.17 (\051 combines a) 456.96 351.67 P
+(class, a class instance \050or) 130.5 338.67 T
+2 F
+(None) 243.52 338.67 T
+1 F
+(\051 and a user-defined function.) 269.92 338.67 T
+0.15 (Special read-only attributes:) 130.5 325.67 P
+2 F
+0.35 (im_self) 257.72 325.67 P
+1 F
+0.15 ( is the instance object;) 303.92 325.67 P
+2 F
+0.35 (im_func) 405.17 325.67 P
+1 F
+0.15 ( is the function) 451.37 325.67 P
+-0.38 (object;) 130.5 312.67 P
+2 F
+-0.92 (im_class) 162.81 312.67 P
+1 F
+-0.38 ( is the class that defined the method \050which may be a base class of the) 215.61 312.67 P
+1.76 (class of which) 130.5 299.67 P
+2 F
+4.22 (im_self) 201.45 299.67 P
+1 F
+1.76 ( is an instance\051;) 247.65 299.67 P
+2 F
+4.22 (__doc__) 326.17 299.67 P
+1 F
+1.76 ( is the method\325s documentation) 372.37 299.67 P
+6.14 (\050same as) 130.5 286.67 P
+2 F
+14.74 (im_func.__doc__) 183.71 286.67 P
+1 F
+6.14 (\051;) 282.71 286.67 P
+2 F
+14.74 (__name__) 298.32 286.67 P
+1 F
+6.14 ( is the method name \050same as) 351.12 286.67 P
+2 F
+(im_func.__name__) 130.5 273.67 T
+1 F
+(\051.) 236.1 273.67 T
+-0.42 (User-defined method objects are created in two ways: when getting an attribute of a class) 130.5 256.67 P
+-0.47 (that is a user-defined function object, or when getting an attributes of a class instance that) 130.5 243.67 P
+0.53 (is a user-defined function object. In the former case \050class attribute\051, the) 130.5 230.67 P
+2 F
+1.28 (im_self) 456.41 230.67 P
+1 F
+0.53 ( at-) 502.61 230.67 P
+-0.01 (tribute is) 130.5 217.67 P
+2 F
+-0.03 (None) 172.03 217.67 P
+1 F
+-0.01 (, and the method object is said to be) 198.43 217.67 P
+3 F
+-0.01 (unbound) 359.02 217.67 P
+1 F
+-0.01 (; in the latter case \050instance) 397.52 217.67 P
+0.4 (attribute\051,) 130.5 204.67 P
+2 F
+0.95 (im_self) 176.72 204.67 P
+1 F
+0.4 ( is the instance, and the method object is said to be) 222.92 204.67 P
+3 F
+0.4 (bound) 453.46 204.67 P
+1 F
+0.4 (. For in-) 480.96 204.67 P
+-0.29 (stance, when) 130.5 191.67 P
+2 F
+-0.7 (C) 189.48 191.67 P
+1 F
+-0.29 ( is a class which contains a definition for a function) 196.08 191.67 P
+2 F
+-0.7 (f) 422.3 191.67 P
+1 F
+-0.29 (,) 428.9 191.67 P
+2 F
+-0.7 (C.f) 434.11 191.67 P
+1 F
+-0.29 ( does not yield) 453.91 191.67 P
+-0.49 (the function object) 130.5 178.67 P
+2 F
+-1.18 (f) 214.26 178.67 P
+1 F
+-0.49 (; rather, it yields an unbound method object m where) 220.86 178.67 P
+2 F
+-1.18 (m.im_class) 451.5 178.67 P
+1 F
+0.17 (is) 130.5 165.67 P
+2 F
+0.41 (C) 140.76 165.67 P
+1 F
+0.17 (,) 147.36 165.67 P
+2 F
+0.41 (m.im_function) 153.03 165.67 P
+1 F
+0.17 ( is) 238.83 165.67 P
+2 F
+0.41 (f) 252.01 165.67 P
+1 F
+0.17 (, and m) 258.61 165.67 P
+2 F
+0.41 (.im_self) 291.64 165.67 P
+1 F
+0.17 ( is) 344.44 165.67 P
+2 F
+0.41 (None) 357.62 165.67 P
+1 F
+0.17 (. When) 384.02 165.67 P
+2 F
+0.41 (x) 418.88 165.67 P
+1 F
+0.17 ( is a) 425.48 165.67 P
+2 F
+0.41 (C) 446.46 165.67 P
+1 F
+0.17 ( instance,) 453.06 165.67 P
+2 F
+0.41 (x.f) 497.7 165.67 P
+1 F
+-0.44 (yields a bound method object) 130.5 152.67 P
+2 F
+-1.05 (m) 260.61 152.67 P
+1 F
+-0.44 ( where) 267.21 152.67 P
+2 F
+-1.05 (m.im_class) 298.71 152.67 P
+1 F
+-0.44 ( is) 364.71 152.67 P
+2 F
+-1.05 (C) 376.68 152.67 P
+1 F
+-0.44 (,) 383.28 152.67 P
+2 F
+-1.05 (m.im_function) 388.34 152.67 P
+1 F
+-0.44 ( is) 474.14 152.67 P
+2 F
+-1.05 (f,) 486.1 152.67 P
+1 F
+-0.44 ( and) 499.3 152.67 P
+2 F
+(m.im_self) 130.5 139.67 T
+1 F
+( is) 189.9 139.67 T
+2 F
+(x) 202.74 139.67 T
+1 F
+(.) 209.34 139.67 T
+3.54 (When an unbound user-defined method object is called, the underlying function) 130.5 122.67 P
+0.32 (\050) 130.5 109.67 P
+2 F
+0.76 (im_func) 134.16 109.67 P
+1 F
+0.32 (\051 is called, with the restriction that the first argument must be an instance of) 180.36 109.67 P
+(the proper class \050) 130.5 96.67 T
+2 F
+(im_class) 205.95 96.67 T
+1 F
+(\051 or of a derived class thereof.) 258.75 96.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "14" 20
+%%Page: "15" 21
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(15) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Data model) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.4 (When a bound user-defined method object is called, the underlying function \050) 153 712.67 P
+2 F
+-0.96 (im_func) 490.14 712.67 P
+1 F
+-0.4 (\051) 536.34 712.67 P
+0.82 (is called, inserting the class instance \050) 153 699.67 P
+2 F
+1.96 (im_self) 323.8 699.67 P
+1 F
+0.82 (\051 in front of the argument list. For in-) 370 699.67 P
+-0.44 (stance, when) 153 686.67 P
+2 F
+-1.06 (C) 211.68 686.67 P
+1 F
+-0.44 ( is a class which contains a definition for a function) 218.28 686.67 P
+2 F
+-1.06 (f) 442.86 686.67 P
+1 F
+-0.44 (, and) 449.46 686.67 P
+2 F
+-1.06 (x) 472.71 686.67 P
+1 F
+-0.44 ( is an instance) 479.31 686.67 P
+(of) 153 673.67 T
+2 F
+(C) 164.91 673.67 T
+1 F
+(, calling) 171.51 673.67 T
+2 F
+(x.f\0501\051) 209.71 673.67 T
+1 F
+( is equivalent to calling) 249.3 673.67 T
+2 F
+(C.f\050x, 1\051) 354.72 673.67 T
+1 F
+(.) 414.12 673.67 T
+0.17 (Note that the transformation from function object to \050unbound or bound\051 method object) 153 656.67 P
+0.4 (happens each time the attribute is retrieved from the class or instance. In some cases, a) 153 643.67 P
+0.32 (fruitful optimization is to assign the attribute to a local variable and call that local vari-) 153 630.67 P
+0.08 (able. Also notice that this transformation only happens for user-defined functions; other) 153 617.67 P
+(callable objects \050and all non-callable objects\051 are retrieved without transformation.) 153 604.67 T
+4 F
+(Built-in functions) 135 585.67 T
+1 F
+0.01 (A built-in function object is a wrapper around a C function. Examples of) 219.96 585.67 P
+0.86 (built-in functions are) 153 572.67 P
+2 F
+2.06 (len) 250.59 572.67 P
+1 F
+0.86 ( and) 270.39 572.67 P
+2 F
+2.06 (math.sin) 293.49 572.67 P
+1 F
+0.86 ( \050) 346.29 572.67 P
+2 F
+2.06 (math) 353.56 572.67 P
+1 F
+0.86 ( is a standard built-in module\051. The) 379.96 572.67 P
+0.44 (number and type of the arguments are determined by the C function. Special read-only) 153 559.67 P
+1.47 (attributes:) 153 546.67 P
+2 F
+3.52 (__doc__) 201.22 546.67 P
+1 F
+1.47 ( is the function\325s documentation string, or) 247.42 546.67 P
+2 F
+3.52 (None) 444.68 546.67 P
+1 F
+1.47 ( if unavailable;) 471.08 546.67 P
+2 F
+1.61 (__name__) 153 533.67 P
+1 F
+0.67 ( is the function\325s name;) 205.8 533.67 P
+2 F
+1.61 (__self__) 315.16 533.67 P
+1 F
+0.67 ( is set to) 367.96 533.67 P
+2 F
+1.61 (None) 409.76 533.67 P
+1 F
+0.67 ( \050but see the next para-) 436.16 533.67 P
+(graph\051.) 153 520.67 T
+4 F
+(Built-in methods) 135 501.67 T
+1 F
+-0.65 (This is really a different disguise of a built-in function, this time containing) 216.29 501.67 P
+0.11 (an object passed to the C function as an implicit extra argument. An example of a built-) 153 488.67 P
+0.73 (in method is) 153 475.67 P
+2 F
+1.76 (list.append) 212.34 475.67 P
+1 F
+0.73 (, assuming) 284.94 475.67 P
+2 F
+1.76 (list) 336.22 475.67 P
+1 F
+0.73 ( is a list object. In this case, the special) 362.62 475.67 P
+(read-only attribute) 153 462.67 T
+2 F
+(__self__) 237.32 462.67 T
+1 F
+( is set to the object denoted by) 290.11 462.67 T
+2 F
+(list) 426.38 462.67 T
+1 F
+(.) 452.78 462.67 T
+4 F
+(Classes) 135 443.67 T
+1 F
+-0.51 (Class objects are described below. When a class object is called, a new class instance) 171.97 443.67 P
+2.98 (\050also described below\051 is created and returned. This implies a call to the class\325s) 153 430.67 P
+2 F
+-0.98 (__init__) 153 417.67 P
+1 F
+-0.41 ( method if it has one. Any arguments are passed on to the) 205.8 417.67 P
+2 F
+-0.98 (__init__) 455.91 417.67 P
+1 F
+-0.41 (meth-) 514.34 417.67 P
+(od \321 if there is no) 153 404.67 T
+2 F
+(__init__) 238.55 404.67 T
+1 F
+( method, the class must be called without arguments.) 291.35 404.67 T
+4 F
+(Class instances) 135 385.67 T
+1 F
+-0.34 (Class instances are described below. Class instances can be called as a func-) 208.34 385.67 P
+0.51 (tion only when the class has a) 153 372.67 P
+2 F
+1.24 (__call__) 290.73 372.67 P
+1 F
+0.51 ( method; in this case,) 343.53 372.67 P
+2 F
+1.24 (x\050arguments\051) 442.05 372.67 P
+1 F
+0.51 ( is a) 521.25 372.67 P
+(shorthand for) 153 359.67 T
+2 F
+(x.__call__\050arguments\051) 214.71 359.67 T
+1 F
+(.) 353.31 359.67 T
+4 F
+(Modules) 99 340.67 T
+1 F
+-0.46 (Modules are imported by the) 142.09 340.67 P
+2 F
+-1.11 (import) 269.62 340.67 P
+1 F
+-0.46 ( statement. \050See \322The import statement\323 on page) 309.22 340.67 P
+-0.46 (43.\051) 522.59 340.67 P
+-0.11 (A module object has a name space implemented by a dictionary object \050this is the dictionary) 135 327.67 P
+0.35 (referenced by the) 135 314.67 P
+2 F
+0.83 (func_globals) 215.14 314.67 P
+1 F
+0.35 ( attribute of functions defined in the module\051. Attribute) 294.34 314.67 P
+4.83 (references are translated to lookups in this dictionary, e.g.) 135 301.67 P
+2 F
+11.6 (m.x) 435.73 301.67 P
+1 F
+4.83 ( is equivalent to) 455.53 301.67 P
+2 F
+1.5 (m.__dict__["x"]) 135 288.67 P
+1 F
+0.62 (. A module object does not contain the code object used to initialize) 234 288.67 P
+(the module \050since it isn\325t needed once the initialization is done\051.) 135 275.67 T
+-0.54 (Attribute assignment update the module\325s name space dictionary, e.g. \324\324) 135 258.67 P
+2 F
+-1.3 (m.x) 446.62 258.67 P
+-1.3 (=) 473.02 258.67 P
+-1.3 (1) 486.22 258.67 P
+1 F
+-0.54 (\325\325 is equiv-) 492.82 258.67 P
+(alent to \324\324) 135 245.67 T
+2 F
+(m.__dict__["x"] = 1) 177.77 245.67 T
+1 F
+(\325\325.) 303.17 245.67 T
+0.89 (Special read-only attribute:) 135 228.67 P
+2 F
+2.13 (__dict__) 260.16 228.67 P
+1 F
+0.89 ( is the dictionary object that is the module\325s name) 312.96 228.67 P
+(space.) 135 215.67 T
+-0.44 (Predefined \050writable\051 attributes:) 135 198.67 P
+2 F
+-1.07 (__name__) 276.94 198.67 P
+1 F
+-0.44 (is the module name;) 335.28 198.67 P
+2 F
+-1.07 (__doc__) 425.16 198.67 P
+1 F
+-0.44 ( is the module\325s) 471.36 198.67 P
+0.38 (documentation string, or) 135 185.67 P
+2 F
+0.92 (None) 246.76 185.67 P
+1 F
+0.38 ( if unavailable;) 273.16 185.67 P
+2 F
+0.92 (__file__) 343.05 185.67 P
+1 F
+0.38 ( is the pathname of the file from) 395.86 185.67 P
+0.47 (which the module was loaded, if it was loaded from a file. The) 135 172.67 P
+2 F
+1.14 (__file__) 419.47 172.67 P
+1 F
+0.47 ( attribute is not) 472.27 172.67 P
+0.86 (present for C modules that are statically linked into the interpreter; for extension modules) 135 159.67 P
+(loaded dynamically from a shared library, it is the pathname of the shared library file.) 135 146.67 T
+4 F
+(Classes) 99 127.67 T
+1 F
+0.34 (Class objects are created by class definitions \050See \322Class definitions\323 on page) 135.97 127.67 P
+0.34 (49.\051. A class) 484.33 127.67 P
+-0.62 (has a name space implemented by a dictionary object. Class attribute references are translated) 135 114.67 P
+0.72 (to lookups in this dictionary, e.g. \324\324) 135 101.67 P
+2 F
+1.72 (C.x) 294.21 101.67 P
+1 F
+0.72 (\325\325 is translated to \324\324) 314.01 101.67 P
+2 F
+1.72 (C.__dict__["x"]) 401.19 101.67 P
+1 F
+0.72 (\325\325. When) 500.19 101.67 P
+0.38 (the attribute name is not found there, the attribute search continues in the base classes. The) 135 88.67 P
+0.02 (search is depth-first, left-to-right in the order of their occurrence in the base class list. When) 135 75.67 P
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "15" 21
+%%Page: "16" 22
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(16) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.46 (a class attribute reference would yield a user-defined function object, it is transformed into) 112.5 712.67 P
+-0.56 (an unbound user-defined method object \050see above\051. The) 112.5 699.67 P
+2 F
+-1.35 (im_class) 361.23 699.67 P
+1 F
+-0.56 ( attribute of this method) 414.03 699.67 P
+-0.22 (object is the class in which the function object was found, not necessarily the class for which) 112.5 686.67 P
+(the attribute reference was initiated.) 112.5 673.67 T
+-0.53 (Class attribute assignments update the class\325s dictionary, never the dictionary of a base class.) 112.5 656.67 P
+(A class object can be called as a function \050see above\051 to yield a class instance \050see below\051.) 112.5 639.67 T
+1.45 (Special read-only attributes:) 112.5 622.67 P
+2 F
+3.47 (__dict__) 243.63 622.67 P
+1 F
+1.45 ( is the dictionary that is the class\325s name space;) 296.43 622.67 P
+2 F
+0.96 (__name__) 112.5 609.67 P
+1 F
+0.4 ( is the class name;) 165.3 609.67 P
+2 F
+0.96 (__bases__) 250.1 609.67 P
+1 F
+0.4 ( is a tuple \050possibly empty or a singleton\051 con-) 309.5 609.67 P
+(taining the base classes, in the order of their occurrence in the base class list.) 112.5 596.67 T
+-0.43 (Predefined \050writable\051 attribute:) 112.5 579.67 P
+2 F
+-1.04 (__doc__) 250.2 579.67 P
+1 F
+-0.43 ( is the class\325s documentation string, or) 296.4 579.67 P
+2 F
+-1.04 (None) 465.08 579.67 P
+1 F
+-0.43 ( if un-) 491.48 579.67 P
+(defined.) 112.5 566.67 T
+4 F
+(Class instances) 76.5 547.67 T
+1 F
+-0.33 (A class instance is created by calling a class object as a function \050see above\051. A class) 149.84 547.67 P
+0.89 (instance has a name space implemented as a dictionary, which is the first place where in-) 112.5 534.67 P
+-0.35 (stance attributes are searched. When an attribute is not found there, the search continues with) 112.5 521.67 P
+0.24 (the class attributes. If a class attribute is found that is a user-defined function object \050and in) 112.5 508.67 P
+-0.53 (no other case\051, it is transformed into an unbound user-defined method object \050see above\051. The) 112.5 495.67 P
+2 F
+3.5 (im_class) 112.5 482.67 P
+1 F
+1.46 ( attribute of this method object is the class in which the function object was) 165.3 482.67 P
+-0.35 (found, not necessarily the class of the instance for which the attribute reference was initiated.) 112.5 469.67 P
+0.96 (If no class attribute is found, and the object\325s class has a) 112.5 456.67 P
+2 F
+2.3 (__getattr__) 374.19 456.67 P
+1 F
+0.96 ( method, that is) 446.79 456.67 P
+(called to satisfy the lookup.) 112.5 443.67 T
+0.38 (Attribute assignments and deletions update the instance\325s dictionary, never a class\325s dictio-) 112.5 426.67 P
+0.18 (nary. If the class has a) 112.5 413.67 P
+2 F
+0.44 (__setattr__) 214.1 413.67 P
+1 F
+0.18 ( or) 286.7 413.67 P
+2 F
+0.44 (__delattr__) 301.72 413.67 P
+1 F
+0.18 ( method, this is called instead of) 374.32 413.67 P
+(updating the instance dictionary directly.) 112.5 400.67 T
+1.16 (Class instances can pretend to be numbers, sequences, mappings, or callable objects, and) 112.5 383.67 P
+0.55 (override various other special operations, if they have methods with certain special names.) 112.5 370.67 P
+(See \322Special method names\323 on page) 112.5 357.67 T
+(18.) 279.91 357.67 T
+-0.09 (Special read-only attributes:) 112.5 340.67 P
+2 F
+-0.22 (__dict__) 239.01 340.67 P
+1 F
+-0.09 ( yields the attribute dictionary;) 291.82 340.67 P
+2 F
+-0.22 (__class__) 429.16 340.67 P
+1 F
+-0.09 ( yields) 488.56 340.67 P
+(the instance\325s class.) 112.5 327.67 T
+4 F
+(Files) 76.5 308.67 T
+1 F
+-0.4 (A file object represents an open file. It is a wrapper around a C standard I/O \050) 112.5 308.67 P
+3 F
+-0.4 (stdio) 446.79 308.67 P
+1 F
+-0.4 (\051 file point-) 468.18 308.67 P
+-0.35 (er. File objects are created by the) 112.5 295.67 P
+2 F
+-0.83 (open\050\051) 258.52 295.67 P
+1 F
+-0.35 ( built-in function, and also by) 298.12 295.67 P
+2 F
+-0.83 (posix.popen\050\051) 428.95 295.67 P
+1 F
+-0.35 (,) 514.75 295.67 P
+2 F
+1.04 (posix.fdopen\050\051) 112.5 282.67 P
+1 F
+0.43 ( and the) 204.9 282.67 P
+2 F
+1.04 (makefile) 243.77 282.67 P
+1 F
+0.43 ( method of socket objects. The objects) 296.57 282.67 P
+2 F
+1.04 (sys.st-) 471.3 282.67 P
+-1.48 (din) 112.5 269.67 P
+1 F
+-0.62 (,) 132.3 269.67 P
+2 F
+-1.48 (sys.stdout) 137.18 269.67 P
+1 F
+-0.62 ( and) 203.18 269.67 P
+2 F
+-1.48 (sys.stderr) 223.33 269.67 P
+1 F
+-0.62 ( are initialized to file objects corresponding to the in-) 289.33 269.67 P
+0.96 (terpreter\325s standard input, output and error streams. See the Python Library Reference for) 112.5 256.67 P
+(methods of file objects and other details.) 112.5 243.67 T
+4 F
+(Internal types) 76.5 224.67 T
+1 F
+-0.69 (A few types used internally by the interpreter are exposed to the user. Their definitions) 144.94 224.67 P
+-0.42 (may change with future versions of the interpreter, but they are mentioned here for complete-) 112.5 211.67 P
+(ness.) 112.5 198.67 T
+4 F
+(Code objects) 112.5 179.67 T
+1 F
+-0.45 (Code objects represent) 175.43 179.67 P
+3 F
+-0.45 (byte-compile) 277.04 179.67 P
+1 F
+-0.45 ( executable Python code, or) 333.85 179.67 P
+3 F
+-0.45 (bytecode) 456.25 179.67 P
+1 F
+-0.45 (. The) 495.34 179.67 P
+-0.5 (difference between a code object and a function object is that the function object contains) 130.5 166.67 P
+0.23 (an explicit reference to the function\325s globals \050the name space dictionary of the module) 130.5 153.67 P
+0.18 (in which it was defined\051, while a code object contains no context; also the default argu-) 130.5 140.67 P
+-0.02 (ment values are stored in the function object, not in the code object \050because they repre-) 130.5 127.67 P
+0.1 (sent values calculated at run-time\051. Unlike function objects, code objects are immutable) 130.5 114.67 P
+(and contain no references \050directly or indirectly\051 to mutable objects.) 130.5 101.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "16" 22
+%%Page: "17" 23
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(17) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Data model) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.03 (Special read-only attributes:) 153 712.67 P
+2 F
+-0.07 (co_argcount) 279.7 712.67 P
+1 F
+-0.03 ( is the number of positional arguments \050in-) 352.3 712.67 P
+0.21 (cluding arguments with default values\051;) 153 699.67 P
+2 F
+0.51 (co_nlocals) 331.58 699.67 P
+1 F
+0.21 ( is the number of local variables) 397.58 699.67 P
+1 (used by the function \050including arguments\051;) 153 686.67 P
+2 F
+2.4 (co_varnames) 354.54 686.67 P
+1 F
+1 ( is a tuple containing the) 427.14 686.67 P
+0.76 (names of the local variables \050starting with the argument names\051;) 153 673.67 P
+2 F
+1.83 (co_code) 445.98 673.67 P
+1 F
+0.76 ( is a string) 492.18 673.67 P
+0.8 (representing the sequence of bytecode instructions;) 153 660.67 P
+2 F
+1.93 (co_consts) 385.72 660.67 P
+1 F
+0.8 ( is a tuple containing) 445.12 660.67 P
+-0.31 (the literals used by the bytecode;) 153 647.67 P
+2 F
+-0.74 (co_names) 298.41 647.67 P
+1 F
+-0.31 ( is a tuple containing the names used by the) 351.21 647.67 P
+4.13 (bytecode;) 153 634.67 P
+2 F
+9.91 (co_filename) 202.65 634.67 P
+1 F
+4.13 ( is the filename from which the code was compiled;) 275.25 634.67 P
+2 F
+1.13 (co_flags) 153 621.67 P
+1 F
+0.47 ( is an integer encoding a number of flags for the interpreter. The following) 205.8 621.67 P
+-0.56 (flag bits are defined: bit 2 is set if the function uses the \322) 153 608.67 P
+2 F
+-1.34 (*arguments) 394.73 608.67 P
+1 F
+-0.56 (\325\325 syntax to accept) 460.73 608.67 P
+2.81 (an arbitrary number of positional arguments; bit 3 is set if the function uses the) 153 595.67 P
+0.11 (\324\324) 153 582.67 P
+2 F
+0.25 (**keywords) 160.33 582.67 P
+1 F
+0.11 (\325\325 syntax to accept arbitrary keyword arguments; other bits are used in-) 226.33 582.67 P
+0.48 (ternally or reserved for future use. The first item in) 153 569.67 P
+2 F
+1.15 (co_consts) 384.75 569.67 P
+1 F
+0.48 ( is the documentation) 444.15 569.67 P
+0.1 (string of the function, or) 153 556.67 P
+2 F
+0.23 (None) 263.47 556.67 P
+1 F
+0.1 ( if undefined. To find out the first line number of a func-) 289.87 556.67 P
+1.57 (tion, you have to disassemble the bytecode instructions; the standard library module) 153 543.67 P
+2 F
+2.59 (codehack) 153 530.67 P
+1 F
+1.08 ( defines a function) 205.8 530.67 P
+2 F
+2.59 (getlineno\050\051) 294.42 530.67 P
+1 F
+1.08 ( that returns the first line number of a) 367.02 530.67 P
+(code object.) 153 517.67 T
+4 F
+(Frame objects) 135 498.67 T
+1 F
+0.15 (Frame objects represent execution frames. They may occur in traceback ob-) 204.64 498.67 P
+(jects \050see below\051.) 153 485.67 T
+-0.2 (Special read-only attributes:) 153 468.67 P
+2 F
+-0.48 (f_back) 279.19 468.67 P
+1 F
+-0.2 ( is to the previous stack frame \050towards the caller\051,) 318.79 468.67 P
+0.09 (or) 153 455.67 P
+2 F
+0.21 (None) 165 455.67 P
+1 F
+0.09 ( if this is the bottom stack frame;) 191.4 455.67 P
+2 F
+0.21 (f_code) 340 455.67 P
+1 F
+0.09 ( is the code object being executed in) 379.6 455.67 P
+0.34 (this frame;) 153 442.67 P
+2 F
+0.82 (f_locals) 203.79 442.67 P
+1 F
+0.34 ( is the dictionary used to look up locals variables;) 256.59 442.67 P
+2 F
+0.82 (f_globals) 480.6 442.67 P
+1 F
+2.99 (is used for global variables;) 153 429.67 P
+2 F
+7.18 (f_builtins) 292.29 429.67 P
+1 F
+2.99 ( is used for built-in \050intrinsic\051 names;) 358.29 429.67 P
+2 F
+0.46 (f_restricted) 153 416.67 P
+1 F
+0.19 ( is a flag indicating whether the function is executing in restricted ex-) 232.2 416.67 P
+-0.49 (ecution mode;) 153 403.67 P
+2 F
+-1.17 (f_owner) 217.41 403.67 P
+1 F
+-0.49 ( is the class or module that defined the code, if any;) 263.61 403.67 P
+2 F
+-1.17 (f_lineno) 487.2 403.67 P
+1 F
+-0.58 (gives the current line number and) 153 390.67 P
+2 F
+-1.39 (f_lasti) 299.83 390.67 P
+1 F
+-0.58 ( gives the precise instruction \050this is an index) 346.03 390.67 P
+(into the instruction string of the code object\051.) 153 377.67 T
+0.9 (Special writable attributes:) 153 360.67 P
+2 F
+2.15 (f_trace) 276.37 360.67 P
+1 F
+0.9 (, if not) 322.57 360.67 P
+2 F
+2.15 (None) 357.04 360.67 P
+1 F
+0.9 (, is a function called at the start of) 383.44 360.67 P
+(each source code line \050this is used by the debugger\051.) 153 347.67 T
+4 F
+(Traceback objects) 135 328.67 T
+1 F
+0.44 ( Traceback objects represent a stack trace of an exception. A traceback) 223.59 328.67 P
+-0.52 (object is created when an exception occurs. When the search for an exception handler un-) 153 315.67 P
+0.3 (winds the execution stack, at each unwound level a traceback object is inserted in front) 153 302.67 P
+-0.24 (of the current traceback. When an exception handler is entered, \050See \322The try statement\323) 153 289.67 P
+9.58 (on page) 153 276.67 P
+9.58 (47.\051, the stack trace is made available to the program as) 199.85 276.67 P
+2 F
+4.44 (sys.exc_traceback) 153 263.67 P
+1 F
+1.85 (. When the program contains no suitable handler, the stack) 265.2 263.67 P
+0.11 (trace is written \050nicely formatted\051 to the standard error stream; if the interpreter is inter-) 153 250.67 P
+(active, it is also made available to the user as) 153 237.67 T
+2 F
+(sys.last_traceback) 353.72 237.67 T
+1 F
+(.) 472.52 237.67 T
+-0.21 (Special read-only attributes:) 135 218.67 P
+2 F
+-0.5 (tb_next) 261.16 218.67 P
+1 F
+-0.21 ( is the next level in the stack trace \050towards the frame) 307.36 218.67 P
+0.45 (where the exception occurred\051, or) 153 205.67 P
+2 F
+1.08 (None) 306.13 205.67 P
+1 F
+0.45 ( if there is no next level;) 332.53 205.67 P
+2 F
+1.08 (tb_frame) 445.35 205.67 P
+1 F
+0.45 ( points to) 498.15 205.67 P
+0.36 (the execution frame of the current level;) 153 192.67 P
+2 F
+0.87 (tb_lineno) 334.85 192.67 P
+1 F
+0.36 ( gives the line number where the) 394.24 192.67 P
+0.58 (exception occurred;) 153 179.67 P
+2 F
+1.39 (tb_lasti) 243.96 179.67 P
+1 F
+0.58 ( indicates the precise instruction. The line number and) 296.76 179.67 P
+-0.25 (last instruction in the traceback may differ from the line number of its frame object if the) 153 166.67 P
+1.72 (exception occurred in a) 153 153.67 P
+2 F
+4.14 (try) 265.58 153.67 P
+1 F
+1.72 ( statement with no matching) 285.38 153.67 P
+2 F
+4.14 (except) 421.41 153.67 P
+1 F
+1.72 ( clause or with a) 461.01 153.67 P
+2 F
+(finally) 153 140.67 T
+1 F
+( clause.) 199.2 140.67 T
+4 F
+(Slice objects) 135 121.67 T
+1 F
+-0.74 (Slice objects are used to represent slices when) 195.49 121.67 P
+3 F
+-0.74 (extended slice syntax) 395.51 121.67 P
+1 F
+-0.74 ( is used \050this) 486.9 121.67 P
+1.72 (is a slice using two colons, or multiple slices or ellipses separated by commas, e.g.) 153 108.67 P
+2 F
+3.58 (a[i:j:step]) 153 95.67 P
+1 F
+1.49 (,) 225.6 95.67 P
+2 F
+3.58 (a[i:j,) 232.59 95.67 P
+3.58 (k:l]) 278.79 95.67 P
+1 F
+1.49 (, or) 305.19 95.67 P
+2 F
+3.58 (a[...,) 325.58 95.67 P
+3.58 (i:j]) 371.79 95.67 P
+1 F
+1.49 (\051. They are also created by the) 398.18 95.67 P
+(built-in) 153 82.67 T
+2 F
+(slice\050\051) 188.15 82.67 T
+1 F
+( function.) 234.35 82.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "17" 23
+%%Page: "18" 24
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(18) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.03 (Special read-only attributes:) 130.5 712.67 P
+2 F
+-0.08 (start) 257.19 712.67 P
+1 F
+-0.03 ( is the lowerbound;) 290.19 712.67 P
+2 F
+-0.08 (stop) 377.44 712.67 P
+1 F
+-0.03 ( is the upperbound;) 403.84 712.67 P
+2 F
+-0.08 (step) 491.1 712.67 P
+1 F
+(is the step value; each is) 130.5 699.67 T
+2 F
+(None) 239.87 699.67 T
+1 F
+( if omitted. These attributes can have any type.) 266.27 699.67 T
+0 14 Q
+(3.3) 76.5 672.67 T
+(Special method names) 112.5 672.67 T
+1 11 Q
+-0.41 (This section describes how user-defined classes can customize their behavior or emulate the behavior) 76.5 643.67 P
+0.14 (of other object types. In the following, if a class defines a particular method, any class derived from) 76.5 630.67 P
+(it is also understood to define that method \050implicitly\051.) 76.5 617.67 T
+-0.27 (A class can implement certain operations that are invoked by special syntax \050such as arithmetic oper-) 76.5 592.67 P
+-0.51 (ations or subscripting and slicing\051 by defining methods with special names. For instance, if a class de-) 76.5 579.67 P
+-0.13 (fines a method named) 76.5 566.67 P
+2 F
+-0.31 (__getitem__) 175.58 566.67 P
+1 F
+-0.13 (, and) 248.18 566.67 P
+2 F
+-0.31 (x) 272.05 566.67 P
+1 F
+-0.13 ( is an instance of this class, then) 278.65 566.67 P
+2 F
+-0.31 (x[i]) 421.52 566.67 P
+1 F
+-0.13 ( is equivalent to) 447.92 566.67 P
+2 F
+0.45 (x.__getitem__\050i\051) 76.5 553.67 P
+1 F
+0.19 (. \050The reverse is not true; e.g. if) 182.1 553.67 P
+2 F
+0.45 (x) 325.03 553.67 P
+1 F
+0.19 ( is a list object,) 331.63 553.67 P
+2 F
+0.45 (x.__getitem__\050i\051) 401.63 553.67 P
+1 F
+0.19 ( is) 507.23 553.67 P
+0.2 (not equivalent to) 76.5 540.67 P
+2 F
+0.48 (x[i]) 153.79 540.67 P
+1 F
+0.2 (.\051 Except where mentioned, attempts to execute an operation raise an excep-) 180.19 540.67 P
+(tion when no appropriate method is defined.) 76.5 527.67 T
+0 12 Q
+(3.3.1) 76.5 502 T
+(Basic customization) 121.5 502 T
+2 11 Q
+(__init__\050self, [args...]\051) 76.5 482.67 T
+1 F
+0.13 (Called when the instance is created. The arguments are those) 248.1 482.67 P
+-0.67 (that were passed to the class constructor expression. If a base class has an) 112.5 469.67 P
+2 F
+-1.62 (__init__) 429.62 469.67 P
+1 F
+-0.67 ( method) 482.42 469.67 P
+0.32 (the derived class\325s) 112.5 456.67 P
+2 F
+0.78 (__init__) 197.48 456.67 P
+1 F
+0.32 ( method must explicitly call it to ensure proper initialization) 250.28 456.67 P
+(of the base class part of the instance, e.g.) 112.5 443.67 T
+(\324\324) 112.5 430.67 T
+2 F
+(BaseClass.__init__\050self,) 119.83 430.67 T
+([args...]\051) 284.83 430.67 T
+1 F
+(\325\325.) 350.83 430.67 T
+2 F
+(__del__\050self\051) 76.5 411.67 T
+1 F
+-0.65 (Called when the instance is about to be destroyed. If a base class has a) 168.9 411.67 P
+2 F
+-1.57 (__del__) 471.3 411.67 P
+1 F
+-0.39 (method the derived class\325s) 112.5 398.67 P
+2 F
+-0.94 (__del__) 230.69 398.67 P
+1 F
+-0.39 ( method must explicitly call it to ensure proper deletion) 276.89 398.67 P
+0.07 (of the base class part of the instance. e.g. \324\324) 112.5 385.67 P
+2 F
+0.17 (BaseClass.__del__\050self\051) 303.16 385.67 P
+1 F
+0.07 (\325\325. Note that it) 454.96 385.67 P
+-0.09 (is possible \050though not recommended!\051 for the) 112.5 372.67 P
+2 F
+-0.22 (__del__) 318.69 372.67 P
+1 F
+-0.09 ( method to postpone destruction of) 364.89 372.67 P
+0.12 (the instance by creating a new reference to it. It may then be called at a later time when this) 112.5 359.67 P
+0.38 (new reference is deleted. It is not guaranteed that) 112.5 346.67 P
+2 F
+0.92 (__del__) 334.67 346.67 P
+1 F
+0.38 ( methods are called for objects) 380.86 346.67 P
+(that still exist when the interpreter exits.) 112.5 333.67 T
+0.16 (Note that \324\324) 112.5 316.67 P
+2 F
+0.38 (del) 163.53 316.67 P
+0.38 (x) 186.24 316.67 P
+1 F
+0.16 (\325\325 doesn\325t directly call) 192.84 316.67 P
+2 F
+0.38 (x.__del__\050\051) 293.67 316.67 P
+1 F
+0.16 ( \321 the former decrements the ref-) 366.27 316.67 P
+-0.19 (erence count for) 112.5 303.67 P
+2 F
+-0.46 (x) 186.14 303.67 P
+1 F
+-0.19 ( by one, and the latter is only called when its reference count reaches zero.) 192.74 303.67 P
+0.15 (Some common situations that may prevent the reference count of an object to go to zero in-) 112.5 290.67 P
+0.68 (clude: circular references between objects \050e.g. a doubly-linked list or a tree data structure) 112.5 277.67 P
+-0.2 (with parent and child pointers\051; a reference to the object on the stack frame of a function that) 112.5 264.67 P
+-0.12 (caught an exception \050the traceback stored in) 112.5 251.67 P
+2 F
+-0.3 (sys.exc_traceback) 308.05 251.67 P
+1 F
+-0.12 ( keeps the stack frame) 420.25 251.67 P
+0.38 (alive\051; or a reference to the object on the stack frame that raised an unhandled exception in) 112.5 238.67 P
+0.64 (interactive mode \050the traceback stored in) 112.5 225.67 P
+2 F
+1.53 (sys.last_traceback) 298.4 225.67 P
+1 F
+0.64 ( keeps the stack frame) 417.2 225.67 P
+0.63 (alive\051. The first situation can only be remedied by explicitly breaking the cycles; the latter) 112.5 212.67 P
+5.8 (two situations can be resolved by storing) 112.5 199.67 P
+2 F
+13.93 (None) 335.52 199.67 P
+1 F
+5.8 ( in) 361.92 199.67 P
+2 F
+13.93 (sys.exc_traceback) 387.58 199.67 P
+1 F
+5.8 ( or) 499.78 199.67 P
+2 F
+(sys.last_traceback) 112.5 186.67 T
+1 F
+(.) 231.3 186.67 T
+3 F
+0.01 (Warning) 112.5 169.67 P
+1 F
+0.01 (: due to the precarious circumstances under which) 151 169.67 P
+2 F
+0.03 (__del__) 374.11 169.67 P
+1 F
+0.01 ( methods are invoked,) 420.31 169.67 P
+2.72 (exceptions that occur during their execution are) 112.5 156.67 P
+3 F
+2.72 (ignored) 343.84 156.67 P
+1 F
+2.72 (, and a warning is printed to) 378.06 156.67 P
+2 F
+0.41 (sys.stderr) 112.5 143.67 P
+1 F
+0.17 ( instead. Also, when) 178.5 143.67 P
+2 F
+0.41 (__del__) 271.46 143.67 P
+1 F
+0.17 ( is invoked is response to a module being de-) 317.66 143.67 P
+-0.53 (leted \050e.g. when execution of the program is done\051, other globals referenced by the) 112.5 130.67 P
+2 F
+-1.28 (__del__) 471.3 130.67 P
+1 F
+-0.56 (method may already have been deleted. For this reason,) 112.5 117.67 P
+2 F
+-1.34 (__del__) 355.23 117.67 P
+1 F
+-0.56 ( methods should do the ab-) 401.43 117.67 P
+(solute minimum needed to maintain external invariants.) 112.5 104.67 T
+2 F
+(__repr__\050self\051) 76.5 85.67 T
+1 F
+1.28 (Called by the) 175.5 85.67 P
+2 F
+3.07 (repr\050\051) 240.74 85.67 P
+1 F
+1.28 ( built-in function and by string conversions \050reverse) 280.34 85.67 P
+1.09 (quotes\051 to compute the \322official\323 string representation of an object. This should normally) 112.5 72.67 P
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "18" 24
+%%Page: "19" 25
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(19) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Data model) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.6 (look like a valid Python expression that can be used to recreate an object with the same value.) 135 712.67 P
+2 F
+(__str__\050self\051) 99 693.67 T
+1 F
+-0.77 (Called by the) 191.4 693.67 P
+2 F
+-1.84 (str\050\051) 250.51 693.67 P
+1 F
+-0.77 ( built-in function and by the) 283.51 693.67 P
+2 F
+-1.84 (print) 404.79 693.67 P
+1 F
+-0.77 (statement compute the) 442.55 693.67 P
+-0.45 (\324\324informal\325\325 string representation of an object. This differs from) 135 680.67 P
+2 F
+-1.08 (__repr__) 414.44 680.67 P
+1 F
+-0.45 ( in that it doesn\325t) 467.24 680.67 P
+-0.44 (have to look like a valid Python expression: a more convenient or concise representation may) 135 667.67 P
+(be used instead.) 135 654.67 T
+2 F
+(__cmp__\050self, other\051) 99 635.67 T
+1 F
+-0.35 (Called by all comparison operations. Should return a negative integer) 237.6 635.67 P
+1.61 (if) 135 622.67 P
+2 F
+3.86 (self) 146.08 622.67 P
+3.86 (<) 175.23 622.67 P
+3.86 (other) 184.58 622.67 P
+1 F
+1.61 (, zero if) 217.58 622.67 P
+2 F
+3.86 (self) 259.06 622.67 P
+3.86 (==) 288.21 622.67 P
+3.86 (other) 304.16 622.67 P
+1 F
+1.61 (, a positive integer if) 337.16 622.67 P
+2 F
+3.86 (self) 438.7 622.67 P
+3.86 (>) 467.85 622.67 P
+3.86 (other) 477.2 622.67 P
+1 F
+1.61 (. If no) 510.2 622.67 P
+2 F
+2.1 (__cmp__) 135 609.67 P
+1 F
+0.88 ( method is defined, class instances are compared by object identity \050\322address\323\051.) 181.2 609.67 P
+-0.23 (\050Implementation note: due to limitations in the interpreter, exceptions raised by comparisons) 135 596.67 P
+(are) 135 583.67 T
+3 F
+(ignored) 151.18 583.67 T
+1 F
+(, and the outcome will be random in this case.\051) 185.4 583.67 T
+2 F
+(__hash__\050self\051) 99 564.67 T
+1 F
+-0.35 (Called for the key object for dictionary operations, and by the built-in function) 198 564.67 P
+2 F
+-0.73 (hash\050\051) 135 551.67 P
+1 F
+-0.3 (. Should return a 32-bit integer usable as a hash value for dictionary operations. The) 174.6 551.67 P
+0.62 (only required property is that objects which compare equal have the same hash value; it is) 135 538.67 P
+0.69 (advised to somehow mix together \050e.g. using exclusive or\051 the hash values for the compo-) 135 525.67 P
+-0.24 (nents of the object that also play a part in comparison of objects. If no) 135 512.67 P
+2 F
+-0.57 (__hash__) 441.84 512.67 P
+1 F
+-0.24 ( method is) 494.64 512.67 P
+0.04 (defined, class instances are hashed by object identity \050\324\324address\325\325\051. If a class does not define) 135 499.67 P
+-0.3 (a) 135 486.67 P
+2 F
+-0.72 (__cmp__) 142.34 486.67 P
+1 F
+-0.3 ( method it should not define a) 188.54 486.67 P
+2 F
+-0.72 (__hash__) 320.58 486.67 P
+1 F
+-0.3 ( method either; if it defines) 373.38 486.67 P
+2 F
+-0.72 (__cmp__) 493.8 486.67 P
+1 F
+-0 (but not) 135 473.67 P
+2 F
+-0.01 (__hash__) 168.61 473.67 P
+1 F
+-0 ( its instances will not be usable as dictionary keys. If a class defines mu-) 221.41 473.67 P
+-0.32 (table objects and implements a) 135 460.67 P
+2 F
+-0.76 (__cmp__) 271.81 460.67 P
+1 F
+-0.32 ( method it should not implement) 318.01 460.67 P
+2 F
+-0.76 (__hash__) 462.16 460.67 P
+1 F
+-0.32 ( since) 514.96 460.67 P
+0.34 (the dictionary implementation requires that a key\325s hash value is immutable \050if the object\325s) 135 447.67 P
+(hash value changes, it will be in the wrong hash bucket\051.) 135 434.67 T
+2 F
+(__nonzero__\050self\051) 384.29 434.67 T
+1 F
+-3.12 (Called to) 503.09 434.67 P
+2.26 (implement truth value testing; should return 0 or 1. When this method is not defined,) 135 421.67 P
+2 F
+3.24 (__len__) 135 408.67 P
+1 F
+1.35 ( is called, if it is defined \050see below\051. If a class defines neither) 181.2 408.67 P
+2 F
+3.24 (__len__) 475.04 408.67 P
+1 F
+1.35 ( nor) 521.24 408.67 P
+2 F
+(__nonzero__) 135 395.67 T
+1 F
+(, all its instances are considered true.) 207.6 395.67 T
+0 12 Q
+(3.3.2) 99 370 T
+(Customizing attribute access) 144 370 T
+1 11 Q
+0.28 (The following methods can be defined to customize the meaning of attribute access \050use of, assign-) 99 344.67 P
+0.41 0.12 (ment to, or deletion of) 99 331.67 B
+2 F
+0.99 0.12 (x.) 204.89 331.67 B
+3 F
+0.41 0.12 (name) 218.34 331.67 B
+1 F
+0.41 0.12 (\051 for class instances. For performance reasons, these methods are) 242.67 331.67 B
+0.41 0.02 (cached in the class object at class definition time; therefore, they cannot be changed after the class) 99 318.67 B
+(definition is executed.) 99 305.67 T
+2 F
+(__getattr__\050self, name\051) 99 286.67 T
+1 F
+-0.39 (Called when an attribute lookup has not found the attribute in the) 257.4 286.67 P
+-0.6 (usual places \050i.e. it is not an instance attribute nor is it found in the class tree for) 135 273.67 P
+2 F
+-1.43 (self) 478.63 273.67 P
+1 F
+-0.6 (\051.) 505.03 273.67 P
+2 F
+-1.43 (name) 513.6 273.67 P
+1 F
+0.67 (is the attribute name. This method should return the \050computed\051 attribute value or raise an) 135 260.67 P
+2 F
+(AttributeError) 135 247.67 T
+1 F
+( exception.) 227.4 247.67 T
+1.22 (Note that if the attribute is found through the normal mechanism,) 135 230.67 P
+2 F
+2.93 (__getattr__) 438.06 230.67 P
+1 F
+1.22 ( is not) 510.66 230.67 P
+0.32 (called. \050This is an asymmetry between) 135 217.67 P
+2 F
+0.76 (__getattr__) 308.89 217.67 P
+1 F
+0.32 ( and) 381.49 217.67 P
+2 F
+0.76 (__setattr__) 403.51 217.67 P
+1 F
+0.32 (.\051 This is done) 476.11 217.67 P
+-0.44 (both for efficiency reasons and because otherwise) 135 204.67 P
+2 F
+-1.06 (__setattr__) 353.97 204.67 P
+1 F
+-0.44 ( would have no way to ac-) 426.57 204.67 P
+-0.62 (cess other attributes of the instance. Note that at least for instance variables, you can fake total) 135 191.67 P
+0.29 (control by not inserting any values in the instance attribute dictionary \050but instead inserting) 135 178.67 P
+(them in another object\051.) 135 165.67 T
+2 F
+(__setattr__\050self, name, value\051) 99 146.67 T
+1 F
+-0.27 (Called whenever an attribute assignment is attempted.) 303.6 146.67 P
+-0.66 (This is called instead of the normal mechanism \050i.e. instead of storing the value in the instance) 135 133.67 P
+(dictionary\051.) 135 120.67 T
+2 F
+(name) 188.77 120.67 T
+1 F
+( is the attribute name,) 215.17 120.67 T
+2 F
+(value) 312.94 120.67 T
+1 F
+( is the value to be assigned to it.) 345.94 120.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "19" 25
+%%Page: "20" 26
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(20) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+1.55 (If) 112.5 712.67 P
+2 F
+3.72 (__setattr__) 124.12 712.67 P
+1 F
+1.55 ( wants to assign to an instance attribute, it should) 196.73 712.67 P
+3 F
+1.55 (not) 431.3 712.67 P
+1 F
+1.55 ( simply execute) 445.35 712.67 P
+0.27 (\324\324) 112.5 699.67 P
+2 F
+0.65 (self.) 119.83 699.67 P
+3 F
+0.27 (name) 152.83 699.67 P
+2 F
+0.65 ( = value) 176.65 699.67 P
+1 F
+0.27 (\325\325 \321 this would cause a recursive call to itself. Instead, it should) 230.75 699.67 P
+(insert the value in the dictionary of instance attributes, e.g.) 112.5 686.67 T
+(\324\324) 112.5 673.67 T
+2 F
+(self.__dict__[name]) 119.83 673.67 T
+(=) 251.83 673.67 T
+(value) 265.03 673.67 T
+1 F
+(\325\325.) 298.03 673.67 T
+2 F
+(__delattr__\050self, name\051) 76.5 654.67 T
+1 F
+-0.33 (Like) 234.9 654.67 P
+2 F
+-0.79 (__setattr__) 257.48 654.67 P
+1 F
+-0.33 ( but for attribute deletion instead of assign-) 330.08 654.67 P
+(ment.) 112.5 641.67 T
+0 12 Q
+(3.3.3) 76.5 616 T
+(Emulating callable objects) 121.5 616 T
+2 11 Q
+(__call__\050self, [args...]\051) 76.5 596.67 T
+1 F
+-0.75 (Called when the instance is \322called\323 as a function; if this meth-) 248.1 596.67 P
+-0.23 (od is defined,) 112.5 583.67 P
+2 F
+-0.55 (x\050arg1, arg2, ...\051) 174.13 583.67 P
+1 F
+-0.23 ( is a shorthand for) 291.83 583.67 P
+2 F
+-0.55 (x.__call__\050arg1, arg2,) 372.85 583.67 P
+(...\051) 112.5 570.67 T
+1 F
+(.) 138.9 570.67 T
+0 12 Q
+(3.3.4) 76.5 545 T
+(Emulating sequence and mapping types) 121.5 545 T
+1 11 Q
+-0.37 (The following methods can be defined to emulate sequence or mapping objects. The first set of meth-) 76.5 519.67 P
+-0.49 (ods is used either to emulate a sequence or to emulate a mapping; the difference is that for a sequence,) 76.5 506.67 P
+0.41 0.07 (the allowable keys should be the integers) 76.5 493.67 B
+3 F
+0.41 0.07 (k) 266.11 493.67 B
+1 F
+0.41 0.07 ( for which 0) 271.06 493.67 B
+2 F
+0.99 0.07 (<=) 329.89 493.67 B
+3 F
+0.41 0.07 (k) 346.47 493.67 B
+2 F
+0.99 0.07 (<) 354.66 493.67 B
+3 F
+0.41 0.07 (N) 364.58 493.67 B
+1 F
+0.41 0.07 ( where) 371.99 493.67 B
+3 F
+0.41 0.07 (N) 405.7 493.67 B
+1 F
+0.41 0.07 ( is the length of the se-) 413.11 493.67 B
+-0.52 (quence, and the method) 76.5 480.67 P
+2 F
+-1.24 (__getslice__) 181.66 480.67 P
+1 F
+-0.52 ( \050see below\051 should be defined. It is also recommended that) 260.86 480.67 P
+-0.16 (mappings provide methods) 76.5 467.67 P
+2 F
+-0.38 (keys) 197.94 467.67 P
+1 F
+-0.16 (,) 224.34 467.67 P
+2 F
+-0.38 (values) 229.69 467.67 P
+1 F
+-0.16 ( and) 269.29 467.67 P
+2 F
+-0.38 (items) 290.36 467.67 P
+1 F
+-0.16 ( behaving similar to those for Python\325s stan-) 323.36 467.67 P
+0.41 0.2 (dard dictionary objects; mutable sequences should provide methods) 76.5 454.67 B
+2 F
+0.99 0.2 (append) 393.4 454.67 B
+1 F
+0.41 0.2 (,) 434.17 454.67 B
+2 F
+0.99 0.2 (count) 440.48 454.67 B
+1 F
+0.41 0.2 (,) 474.46 454.67 B
+2 F
+0.99 0.2 (index) 480.77 454.67 B
+1 F
+0.41 0.2 (,) 514.75 454.67 B
+2 F
+0.99 0 (insert) 76.5 441.67 B
+1 F
+0.41 0 (,) 116.11 441.67 B
+2 F
+0.99 0 (sort) 122.02 441.67 B
+1 F
+0.41 0 (,) 148.43 441.67 B
+2 F
+0.99 0 (remove) 154.34 441.67 B
+1 F
+0.41 0 ( and) 193.95 441.67 B
+2 F
+0.99 0 (reverse) 216.16 441.67 B
+1 F
+0.41 0 ( like Python standard list objects. Finally, sequence types) 262.37 441.67 B
+0.41 0.01 (should implement addition \050meaning concatenation\051 and multiplication \050meaning repetition\051 by de-) 76.5 428.67 B
+-0.55 (fining the methods) 76.5 415.67 P
+2 F
+-1.31 (__add__) 160.11 415.67 P
+1 F
+-0.55 (,) 206.31 415.67 P
+2 F
+-1.31 (__radd__) 211.27 415.67 P
+1 F
+-0.55 (,) 264.07 415.67 P
+2 F
+-1.31 (__mul__) 269.02 415.67 P
+1 F
+-0.55 ( and) 315.22 415.67 P
+2 F
+-1.31 (__rmul__) 335.51 415.67 P
+1 F
+-0.55 ( described below; they should) 388.31 415.67 P
+(not define) 76.5 402.67 T
+2 F
+(__coerce__) 123.55 402.67 T
+1 F
+( or other numerical operators.) 189.55 402.67 T
+2 F
+(__len__\050self\051) 76.5 383.67 T
+1 F
+-0.67 (Called to implement the built-in function) 168.9 383.67 P
+2 F
+-1.6 (len\050\051) 348.25 383.67 P
+1 F
+-0.67 (. Should return the length of the) 381.25 383.67 P
+-0.16 (object, an integer) 112.5 370.67 P
+2 F
+-0.39 (>=) 190.83 370.67 P
+1 F
+-0.16 ( 0. Also, an object that doesn\325t define a) 204.03 370.67 P
+2 F
+-0.39 (__nonzero__\050\051) 377.64 370.67 P
+1 F
+-0.16 ( method and) 463.44 370.67 P
+(whose) 112.5 357.67 T
+2 F
+(__len__\050\051) 143.35 357.67 T
+1 F
+( method returns zero is considered to be false in a Boolean context.) 202.76 357.67 T
+2 F
+(__getitem__\050self, key\051) 76.5 338.67 T
+1 F
+-0.74 (Called to implement evaluation of) 228.3 338.67 P
+2 F
+-1.78 (self[key]) 377.67 338.67 P
+1 F
+-0.74 (. Note that the spe-) 437.07 338.67 P
+0.38 (cial interpretation of negative keys \050if the class wishes to emulate a sequence type\051 is up to) 112.5 325.67 P
+(the) 112.5 312.67 T
+2 F
+(__getitem__) 128.69 312.67 T
+1 F
+( method.) 201.29 312.67 T
+2 F
+(__setitem__\050self, key, value\051) 76.5 293.67 T
+1 F
+-0.41 (Called to implement assignment to) 274.5 293.67 P
+2 F
+-1 (self[key]) 428.57 293.67 P
+1 F
+-0.41 (. Same) 487.97 293.67 P
+(note as for) 112.5 280.67 T
+2 F
+(__getitem__) 161.68 280.67 T
+1 F
+(.) 234.28 280.67 T
+2 F
+(__delitem__\050self, key\051) 76.5 261.67 T
+1 F
+0.89 (Called to implement deletion of) 228.3 261.67 P
+2 F
+2.13 (self[key]) 375.43 261.67 P
+1 F
+0.89 (. Same note as for) 434.83 261.67 P
+2 F
+(__getitem__) 112.5 248.67 T
+1 F
+(.) 185.1 248.67 T
+0 F
+(3.3.4.1) 76.5 226.67 T
+(Additional methods for emulation of sequence types) 121.5 226.67 T
+1 F
+-0.39 (The following methods can be defined to further emulate sequence objects. For immutable sequences) 76.5 201.67 P
+-0.15 (methods, only) 76.5 188.67 P
+2 F
+-0.35 (__getslice__) 141.29 188.67 P
+1 F
+-0.15 ( should be defined; for mutable sequences, all three methods should) 220.49 188.67 P
+(be defined.) 76.5 175.67 T
+2 F
+(__getslice__\050self, i, j\051) 76.5 156.67 T
+1 F
+0.22 (Called to implement evaluation of) 241.5 156.67 P
+2 F
+0.52 (self[i:j]) 395.66 156.67 P
+1 F
+0.22 (. The returned) 455.06 156.67 P
+0.15 (object should be of the same type as) 112.5 143.67 P
+2 F
+0.37 (self) 275.64 143.67 P
+1 F
+0.15 (. Note that missing) 302.04 143.67 P
+2 F
+0.37 (i) 388.51 143.67 P
+1 F
+0.15 ( or) 395.11 143.67 P
+2 F
+0.37 (j) 410.08 143.67 P
+1 F
+0.15 ( in the slice expression) 416.68 143.67 P
+0.09 (are replaced by 0 or) 112.5 130.67 P
+2 F
+0.22 (len\050self\051) 203.07 130.67 P
+1 F
+0.09 (, respectively, and) 262.47 130.67 P
+2 F
+0.22 (len\050self\051) 345.53 130.67 P
+1 F
+0.09 ( has been added \050once\051 to) 404.93 130.67 P
+(originally negative) 112.5 117.67 T
+2 F
+(i) 198.05 117.67 T
+1 F
+( or) 204.65 117.67 T
+2 F
+(j) 219.31 117.67 T
+1 F
+( by the time this function is called \050unlike for) 225.91 117.67 T
+2 F
+(__getitem__) 427.56 117.67 T
+1 F
+(\051.) 500.16 117.67 T
+2 F
+(__setslice__\050self, i, j, sequence\051) 76.5 98.67 T
+1 F
+-1.66 (Called to implement assignment to) 307.5 98.67 P
+2 F
+-3.98 (self[i:j]) 455.35 98.67 P
+1 F
+-1.66 (.) 514.75 98.67 P
+-0.16 (The) 112.5 85.67 P
+2 F
+-0.39 (sequence) 132.19 85.67 P
+1 F
+-0.16 ( argument can have any type. The return value should be) 184.99 85.67 P
+2 F
+-0.39 (None) 435.52 85.67 P
+1 F
+-0.16 (. Same notes) 461.92 85.67 P
+(for) 112.5 72.67 T
+2 F
+(i) 128.08 72.67 T
+1 F
+( and) 134.68 72.67 T
+2 F
+(j) 156.06 72.67 T
+1 F
+( as for) 162.66 72.67 T
+2 F
+(__getslice__) 192.9 72.67 T
+1 F
+(.) 272.1 72.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "20" 26
+%%Page: "21" 27
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(21) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Data model) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 11 Q
+(__delslice__\050self, i, j\051) 99 712.67 T
+1 F
+-0.77 (Called to implement deletion of) 264 712.67 P
+2 F
+-1.85 (self[i:j]) 402.84 712.67 P
+1 F
+-0.77 (. Same notes for) 462.24 712.67 P
+2 F
+-1.85 (i) 533.4 712.67 P
+1 F
+(and) 135 699.67 T
+2 F
+(j) 153.63 699.67 T
+1 F
+( as for) 160.23 699.67 T
+2 F
+(__getslice__) 190.47 699.67 T
+1 F
+(.) 269.67 699.67 T
+0.08 (Notice that these methods are only invoked when a single slice with a single colon is used. For slice) 99 674.67 P
+0.33 (operations involving) 99 661.67 P
+3 F
+0.33 (extended slice notation) 193.15 661.67 P
+1 F
+0.33 (,) 295.23 661.67 P
+2 F
+0.78 (__getitem__) 301.06 661.67 P
+1 F
+0.33 (,) 373.66 661.67 P
+2 F
+0.78 (__setitem__) 379.49 661.67 P
+1 F
+0.33 ( or) 452.08 661.67 P
+2 F
+0.78 (__delitem__) 467.4 661.67 P
+1 F
+(is called.) 99 648.67 T
+0 12 Q
+(3.3.5) 99 623 T
+(Emulating numeric types) 144 623 T
+1 11 Q
+-0.15 (The following methods can be defined to emulate numeric objects. Methods corresponding to opera-) 99 597.67 P
+-0.54 (tions that are not supported by the particular kind of number implemented \050e.g., bitwise operations for) 99 584.67 P
+(non-integral numbers\051 should be left undefined.) 99 571.67 T
+2 F
+(__add__\050self, right\051) 99 552.67 T
+(__sub__\050self, right\051) 99 539.67 T
+(__mul__\050self, right\051) 99 526.67 T
+(__div__\050self, right\051) 99 513.67 T
+(__mod__\050self, right\051) 99 500.67 T
+(__divmod__\050self, right\051) 99 487.67 T
+(__pow__\050self, right\051) 99 474.67 T
+(__lshift__\050self, right\051) 99 461.67 T
+(__rshift__\050self, right\051) 99 448.67 T
+(__and__\050self, right\051) 99 435.67 T
+(__xor__\050self, right\051) 99 422.67 T
+(__or__\050self, right\051) 99 409.67 T
+1 F
+0.44 (These functions are called to implement the binary arithmetic operations \050+, -, *, /, %, div-) 135 396.67 P
+0.67 (mod\050\051, pow\050\051, <<, >>, &, ^, |\051. For instance: to evaluate the expression x+y, where x is an) 135 383.67 P
+(instance of a class that has an __add__ method, x.__add__\050y\051 is called.) 135 370.67 T
+2 F
+(__radd__\050self, left\051) 99 351.67 T
+(__rsub__\050self, left\051) 99 338.67 T
+(__rmul__\050self, left\051) 99 325.67 T
+(__rdiv__\050self, left\051) 99 312.67 T
+(__rmod__\050self, left\051) 99 299.67 T
+(__rdivmod__\050self, left\051) 99 286.67 T
+(__rpow__\050self, left\051) 99 273.67 T
+(__rlshift__\050self, left\051) 99 260.67 T
+(__rrshift__\050self, left\051) 99 247.67 T
+(__rand__\050self, left\051) 99 234.67 T
+(__rxor__\050self, left\051) 99 221.67 T
+(__ror__\050self, left\051) 99 208.67 T
+1 F
+-1.3 ( These functions are called to implement the binary arithmetic operations) 231 208.67 P
+-0.5 (\050) 135 195.67 P
+2 F
+-1.21 (+) 138.66 195.67 P
+1 F
+-0.5 (,) 145.26 195.67 P
+2 F
+-1.21 (-) 150.26 195.67 P
+1 F
+-0.5 (,) 156.86 195.67 P
+2 F
+-1.21 (*) 161.85 195.67 P
+1 F
+-0.5 (,) 168.46 195.67 P
+2 F
+-1.21 (/) 173.45 195.67 P
+1 F
+-0.5 (,) 180.05 195.67 P
+2 F
+-1.21 (%) 185.05 195.67 P
+1 F
+-0.5 (,) 191.65 195.67 P
+2 F
+-1.21 (divmod\050\051) 196.64 195.67 P
+1 F
+-0.5 (,) 249.44 195.67 P
+2 F
+-1.21 (pow\050\051) 254.44 195.67 P
+1 F
+-0.5 (,) 287.44 195.67 P
+2 F
+-1.21 (<<) 292.44 195.67 P
+1 F
+-0.5 (,) 305.64 195.67 P
+2 F
+-1.21 (>>) 310.63 195.67 P
+1 F
+-0.5 (,) 323.83 195.67 P
+2 F
+-1.21 (&) 328.83 195.67 P
+1 F
+-0.5 (,) 335.43 195.67 P
+2 F
+-1.21 (^) 340.42 195.67 P
+1 F
+-0.5 (,) 347.02 195.67 P
+2 F
+-1.21 (|) 352.02 195.67 P
+1 F
+-0.5 (\051 with reversed operands. These functions) 358.62 195.67 P
+-0.62 (are only called if the left operand does not support the corresponding operation \050possibly after) 135 182.67 P
+-0.09 (coercion\051. For instance: to evaluate the expression x+y, where x is an instance of a class that) 135 169.67 P
+2.63 (does not have an) 135 156.67 P
+2 F
+6.31 (__add__) 221.89 156.67 P
+1 F
+2.63 ( method,) 268.09 156.67 P
+2 F
+6.31 (y.__radd\050x\051) 314.59 156.67 P
+1 F
+2.63 ( is called. If the class defines a) 387.19 156.67 P
+0.37 (__coerce__ method that coerces its arguments to a common type, these methods will never) 135 143.67 P
+0.54 (be called and thus needn\325t be defined. They are useful for classes that implement semi-nu-) 135 130.67 P
+-0.53 (merical data types \050types that have some numerical behavior but don\325t adhere to all invariants) 135 117.67 P
+(usually assumed about numbers\051.) 135 104.67 T
+2 F
+(__neg__\050self\051) 99 85.67 T
+(__pos__\050self\051) 99 72.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "21" 27
+%%Page: "22" 28
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(22) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 11 Q
+(__abs__\050self\051) 76.5 712.67 T
+(__invert__\050self\051) 76.5 699.67 T
+1 F
+-0.14 ( Called to implement the unary arithmetic operations \050) 188.7 699.67 P
+2 F
+-0.34 (-) 426.48 699.67 P
+1 F
+-0.14 (,) 433.08 699.67 P
+2 F
+-0.34 (+) 438.43 699.67 P
+1 F
+-0.14 (,) 445.03 699.67 P
+2 F
+-0.34 (abs\050\051) 450.39 699.67 P
+1 F
+-0.14 ( and) 483.39 699.67 P
+2 F
+-0.34 (~) 504.49 699.67 P
+1 F
+-0.14 (\051.) 511.09 699.67 P
+2 F
+(__int__\050self\051) 76.5 680.67 T
+(__long__\050self\051) 76.5 667.67 T
+(__float__\050self\051) 76.5 654.67 T
+1 F
+-0.34 ( Called to implement the built-in functions) 182.1 654.67 P
+2 F
+-0.82 (int\050\051) 370.09 654.67 P
+1 F
+-0.34 (,) 403.09 654.67 P
+2 F
+-0.82 (long\050\051) 408.25 654.67 P
+1 F
+-0.34 ( and) 447.85 654.67 P
+2 F
+-0.82 (float\050\051) 468.55 654.67 P
+1 F
+-0.34 (.) 514.75 654.67 P
+(Should return a value of the appropriate type.) 112.5 641.67 T
+2 F
+(__oct__\050self\051) 76.5 622.67 T
+(__hex__\050self\051) 76.5 609.67 T
+1 F
+-0.21 ( Called to implement the built-in functions) 168.9 609.67 P
+2 F
+-0.5 (oct\050\051) 357.82 609.67 P
+1 F
+-0.21 ( and) 390.82 609.67 P
+2 F
+-0.5 (hex\050\051) 411.79 609.67 P
+1 F
+-0.21 (. Should return a) 444.79 609.67 P
+(string value.) 112.5 596.67 T
+2 F
+(__coerce__\050self, other\051) 76.5 577.67 T
+1 F
+0.3 (Called to implement \322mixed-mode\323 numeric arithmetic. Should) 234.9 577.67 P
+-0.34 (either return a 2-tuple containing) 112.5 564.67 P
+2 F
+-0.82 (self) 258.34 564.67 P
+1 F
+-0.34 ( and) 284.74 564.67 P
+2 F
+-0.82 (other) 305.43 564.67 P
+1 F
+-0.34 ( converted to a common numeric type, or) 338.43 564.67 P
+2 F
+0.6 (None) 112.5 551.67 P
+1 F
+0.25 ( if no conversion is possible. When the common type would be the type of) 138.9 551.67 P
+2 F
+0.6 (other) 472.63 551.67 P
+1 F
+0.25 (, it) 505.63 551.67 P
+0.46 (is sufficient to return) 112.5 538.67 P
+2 F
+1.11 (None) 209.06 538.67 P
+1 F
+0.46 (, since the interpreter will also ask the other object to attempt a) 235.46 538.67 P
+-0.39 (coercion \050but sometimes, if the implementation of the other type cannot be changed, it is use-) 112.5 525.67 P
+(ful to do the conversion to the other type here\051.) 112.5 512.67 T
+4 F
+1.86 (Coercion rules) 112.5 495.67 P
+1 F
+1.86 (: to evaluate x) 183.1 495.67 P
+3 F
+1.86 (op) 255.29 495.67 P
+1 F
+1.86 ( y, the following steps are taken \050where) 266.29 495.67 P
+2 F
+4.46 (__op__) 457.41 495.67 P
+1 F
+1.86 ( and) 497.01 495.67 P
+2 F
+4.69 (__rop__) 112.5 482.67 P
+1 F
+1.96 ( are the method names corresponding to) 158.7 482.67 P
+3 F
+1.96 (op) 351.11 482.67 P
+1 F
+1.96 (, e.g. if) 362.11 482.67 P
+3 F
+1.96 (op) 401.58 482.67 P
+1 F
+1.96 ( is \324) 412.58 482.67 P
+2 F
+4.69 (+) 432.99 482.67 P
+1 F
+1.96 (\325,) 439.59 482.67 P
+2 F
+4.69 (__add__) 450.71 482.67 P
+1 F
+1.96 ( and) 496.91 482.67 P
+2 F
+0.89 (__radd__) 112.5 469.67 P
+1 F
+0.37 ( are used\051. If an exception occurs at any point, the evaluation is abandoned and) 165.3 469.67 P
+(exception handling takes over.) 112.5 456.67 T
+(0.) 112.5 437.67 T
+0.31 (If x is a string object and) 130.5 437.67 P
+3 F
+0.31 (op) 244.77 437.67 P
+1 F
+0.31 ( is the modulo operator \050) 255.77 437.67 P
+2 F
+0.74 (%) 365.77 437.67 P
+1 F
+0.31 (\051, the string formatting operation) 372.37 437.67 P
+(\050see [Ref:XXX]\051 is invoked and the remaining steps are skipped.) 130.5 424.67 T
+(1.) 112.5 405.67 T
+(If x is a class instance:) 130.5 405.67 T
+(1a.) 130.5 386.67 T
+0.54 (If x has a) 166.5 386.67 P
+2 F
+1.3 (__coerce__) 212.05 386.67 P
+1 F
+0.54 ( method: replace x and y with the 2-tuple returned by) 278.05 386.67 P
+2 F
+(x.__coerce__\050y\051) 166.5 373.67 T
+1 F
+(; skip to step 2 if the coercion returns) 265.5 373.67 T
+2 F
+(None) 432.01 373.67 T
+1 F
+(.) 458.41 373.67 T
+(1b.) 130.5 354.67 T
+(If neither x nor y is a class instance after coercion, go to step 3.) 166.5 354.67 T
+(1c.) 130.5 335.67 T
+-0.41 (If x has a method) 166.5 335.67 P
+2 F
+-0.98 (__op__) 243.59 335.67 P
+1 F
+-0.41 (, return) 283.19 335.67 P
+2 F
+-0.98 (x.__op__\050y\051) 316.89 335.67 P
+1 F
+-0.41 (; otherwise, restore x and y to) 389.49 335.67 P
+(their value before step 1a.) 166.5 322.67 T
+(2.) 112.5 303.67 T
+(If y is a class instance:) 130.5 303.67 T
+(2a.) 130.5 284.67 T
+0.54 (If y has a) 166.5 284.67 P
+2 F
+1.3 (__coerce__) 212.05 284.67 P
+1 F
+0.54 ( method: replace y and x with the 2-tuple returned by) 278.05 284.67 P
+2 F
+(y.__coerce__\050x\051) 166.5 271.67 T
+1 F
+(; skip to step 3 if the coercion returns None.) 265.5 271.67 T
+(2b.) 130.5 252.67 T
+(If neither x nor y is a class instance after coercion, go to step 3.) 166.5 252.67 T
+(2b.) 130.5 233.67 T
+0.1 (If y has a method) 166.5 233.67 P
+2 F
+0.23 (__rop__) 246.11 233.67 P
+1 F
+0.1 (, return) 292.31 233.67 P
+2 F
+0.23 (y.__rop__\050x\051) 327.02 233.67 P
+1 F
+0.1 (; otherwise, restore x and) 406.22 233.67 P
+(y to their value before step 2a.) 166.5 220.67 T
+(3.) 112.5 201.67 T
+(We only get here if neither x nor y is a class instance.) 130.5 201.67 T
+(3a.) 130.5 182.67 T
+(If) 166.5 182.67 T
+3 F
+(op) 176.58 182.67 T
+1 F
+( is \324) 187.58 182.67 T
+2 F
+(+) 204.08 182.67 T
+1 F
+(\325 and x is a sequence, sequence concatenation is invoked.) 210.68 182.67 T
+(3b.) 130.5 163.67 T
+-0.37 (If) 166.5 163.67 P
+3 F
+-0.37 (op) 176.2 163.67 P
+1 F
+-0.37 ( is \324) 187.2 163.67 P
+2 F
+-0.89 (*) 202.96 163.67 P
+1 F
+-0.37 (\325 and one operand is a sequence and the other an integer, sequence rep-) 209.56 163.67 P
+(etition is invoked.) 166.5 150.67 T
+(3c.) 130.5 131.67 T
+0.05 (Otherwise, both operands must be numbers; they are coerced to a common type) 166.5 131.67 P
+(if possible, and the numeric operation is invoked for that type.) 166.5 118.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "22" 28
+%%Page: "23" 29
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(23) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Execution model) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 16 Q
+(C) 99 709.33 T
+0 12.8 Q
+(HAPTER) 110.55 709.33 T
+0 16 Q
+(4:) 167.62 709.33 T
+(E) 198 709.33 T
+0 12.8 Q
+(XECUTION) 208.67 709.33 T
+(MODEL) 279.26 709.33 T
+0 14 Q
+(4.1) 99 670.67 T
+(Code blocks, execution frames, and name spaces) 135 670.67 T
+1 11 Q
+0.53 (A) 99 645.67 P
+3 F
+0.53 (code block) 110.22 645.67 P
+1 F
+0.53 ( is a piece of Python program text that can be executed as a unit, such as a module, a) 158.1 645.67 P
+1.1 (class definition or a function body. Some code blocks \050like modules\051 are normally executed only) 99 632.67 P
+0.12 (once, others \050like function bodies\051 may be executed many times. Code blocks may textually contain) 99 619.67 P
+-0.19 (other code blocks. Code blocks may invoke other code blocks \050that may or may not be textually con-) 99 606.67 P
+(tained in them\051 as part of their execution, e.g. by invoking \050calling\051 a function.) 99 593.67 T
+0.3 (The following are code blocks: A module is a code block. A function body is a code block. A class) 99 568.67 P
+-0.15 (definition is a code block. Each command typed interactively is a separate code block; a script file \050a) 99 555.67 P
+-0.24 (file given as standard input to the interpreter or specified on the interpreter command line the first ar-) 99 542.67 P
+0.41 0.02 (gument\051 is a code block; a script command \050a command specified on the interpreter command line) 99 529.67 B
+-0.24 (with the \324) 99 516.67 P
+4 F
+-0.24 (-c) 140.69 516.67 P
+1 F
+-0.24 (\325 option\051 is a code block. The string argument passed to the built-in function) 149.24 516.67 P
+2 F
+-0.57 (eval) 484.13 516.67 P
+1 F
+-0.24 ( and to) 510.53 516.67 P
+0.41 0.14 (the) 99 503.67 B
+2 F
+0.99 0.14 (exec) 116.15 503.67 B
+1 F
+0.41 0.14 ( statement are code blocks. The file read by the built-in function) 143.09 503.67 B
+2 F
+0.99 0.14 (execfile) 442.15 503.67 B
+1 F
+0.41 0.14 ( is a code) 496.03 503.67 B
+-0.3 (block. And finally, the expression read and evaluated by the built-in function) 99 490.67 P
+2 F
+-0.71 (input) 437 490.67 P
+1 F
+-0.3 ( is a code block.) 470 490.67 P
+-0.42 (A code block is executed in an execution frame. An) 99 477.67 P
+3 F
+-0.42 (execution frame) 325.47 477.67 P
+1 F
+-0.42 ( contains some administrative in-) 395.62 477.67 P
+0.41 0.23 (formation \050used for debugging\051, determines where and how execution continues after the code) 99 464.67 B
+-0.13 (block\325s execution has completed, and \050perhaps most importantly\051 defines two name spaces, the local) 99 451.67 P
+(and the global name space, that affect execution of the code block.) 99 438.67 T
+-0.04 (A) 99 413.67 P
+3 F
+-0.04 (name space) 109.65 413.67 P
+1 F
+-0.04 ( is a mapping from names \050identifiers\051 to objects. A particular name space may be ref-) 161.23 413.67 P
+0.03 (erenced by more than one execution frame, and from other places as well. Adding a name to a name) 99 400.67 P
+-0.38 (space is called) 99 387.67 P
+3 F
+-0.38 (binding) 164.14 387.67 P
+1 F
+-0.38 ( a name \050to an object\051; changing the mapping of a name is called) 197.76 387.67 P
+3 F
+-0.38 (rebinding) 479.58 387.67 P
+1 F
+-0.38 (; re-) 522.36 387.67 P
+0.05 (moving a name is) 99 374.67 P
+3 F
+0.05 (unbinding) 179.88 374.67 P
+1 F
+0.05 (. Name spaces are functionally equivalent to dictionaries \050and often im-) 224.49 374.67 P
+(plemented as dictionaries\051.) 99 361.67 T
+0.41 0.01 (The) 99 336.67 B
+3 F
+0.41 0.01 (local name space) 119.3 336.67 B
+1 F
+0.41 0.01 ( of an execution frame determines the default place where names are defined) 196.62 336.67 B
+-0.5 (and searched. The) 99 323.67 P
+3 F
+-0.5 (global name space) 179.96 323.67 P
+1 F
+-0.5 ( determines the place where names listed in) 261.44 323.67 P
+2 F
+-1.21 (global) 451.71 323.67 P
+1 F
+-0.5 ( statements) 491.31 323.67 P
+-0.36 (are defined and searched, and where names that are not bound anywhere in the current code block are) 99 310.67 P
+(searched.) 99 297.67 T
+-0.31 (Whether a name is local or global in a code block is determined by static inspection of the source text) 99 272.67 P
+-0.19 (for the code block: in the absence of) 99 259.67 P
+2 F
+-0.45 (global) 260.01 259.67 P
+1 F
+-0.19 ( statements, a name that is bound anywhere in the code) 299.61 259.67 P
+-0.21 (block is local in the entire code block; all other names are considered global. The) 99 246.67 P
+2 F
+-0.51 (global) 455.7 246.67 P
+1 F
+-0.21 ( statement) 495.3 246.67 P
+0.27 (forces global interpretation of specified names throughout the code block. The following constructs) 99 233.67 P
+0.41 0.17 (bind names: formal parameters to functions,) 99 220.67 B
+2 F
+0.99 0.17 (import) 306.04 220.67 B
+1 F
+0.41 0.17 ( statements, class and function definitions) 346.67 220.67 B
+-0.01 (\050these bind the class or function name in the defining block\051, and targets that are identifiers if occur-) 99 207.67 P
+-0.54 (ring in an assignment,) 99 194.67 P
+2 F
+-1.3 (for) 196.75 194.67 P
+1 F
+-0.54 ( loop header, or in the second position of an) 216.55 194.67 P
+2 F
+-1.3 (except) 409.17 194.67 P
+1 F
+-0.54 ( clause header. Local) 448.77 194.67 P
+0.3 (names are searched only on the local name space; global names are searched only in the global and) 99 181.67 P
+(built-in namespace.) 99 168.67 T
+1 8.8 Q
+(1) 185.15 173.07 T
+1 11 Q
+-0.4 (A target occurring in a) 99 143.67 P
+2 F
+-0.96 (del) 199.33 143.67 P
+1 F
+-0.4 ( statement is also considered bound for this purpose \050though the actual se-) 219.13 143.67 P
+(mantics are to \322unbind\323 the name\051.) 99 130.67 T
+0 0 0 1 0 0 0 K
+99 99 540 114 C
+0 0 0 1 0 0 0 K
+108 112 252 112 2 L
+0.5 H
+2 Z
+0 X
+0 0 0 1 0 0 0 K
+N
+0 0 0 1 0 0 0 K
+0 0 612 792 C
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(1.) 108 92.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.35 (If the code block contains) 121.5 92.33 P
+2 F
+-0.83 (exec) 225.57 92.33 P
+1 F
+-0.35 ( statements or the construct \324\324) 249.57 92.33 P
+2 F
+-0.83 (from) 366.42 92.33 P
+-0.83 (...) 392.57 92.33 P
+-0.83 (import) 412.72 92.33 P
+-0.83 (*) 450.88 92.33 P
+1 F
+-0.35 (\325\325, the semantics) 456.88 92.33 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.61 (of local names change subtly: local name lookup first searches in the local namespace, then in the) 121.46 80.33 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(global namespace and in the built-in namespace.) 121.46 68.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "23" 29
+%%Page: "24" 30
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(24) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.41 0.03 (When a global name is not found in the global name space, it is searched in the built-in namespace. The) 72 712.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.02 (built-in namespace associated with the execution of a code block is actually found by looking up the name) 72 699.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+-0.87 (__builtins__) 72 686.67 P
+1 F
+-0.36 ( is its global name space; this should be a dictionary or a module \050in the latter case its dic-) 151.2 686.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.24 (tionary is used\051. Normally, the) 72 673.67 B
+2 F
+0.99 0.24 (__builtins__) 218.94 673.67 B
+1 F
+0.41 0.24 ( namespace is the dictionary of the built-in module) 301.03 673.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+0.99 0.05 (__builtin__) 72 660.67 B
+1 F
+0.41 0.05 ( \050note: no \324s\325\051; if it isn\325t,) 145.11 660.67 B
+3 F
+0.41 0.05 (restricted execution mode) 258.78 660.67 B
+1 F
+0.41 0.05 ( is in effect, see [Ref:XXX]. When a) 374.41 660.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(name is not found at all, a) 72 647.67 T
+2 F
+(NameError) 188.71 647.67 T
+1 F
+( exception is raised.) 248.11 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.19 (The following table lists the local and global name space used for all types of code blocks. The name space) 72 622.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.28 (for a particular module is automatically created when the module is first imported. Note that in almost all) 72 609.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.16 (cases, the global name space is the name space of the containing module \321 scopes in Python do not nest!) 72 596.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Notes:) 72 313.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 F
+(n.s.) 72 294.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(means) 108 294.67 T
+3 F
+(name space) 138.85 294.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 F
+(\0501\051) 72 275.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(The main module for a script is always called) 108 275.67 T
+2 F
+(__main__) 311.16 275.67 T
+1 F
+(; \324\324the filename don\325t enter into it.\325\325) 363.96 275.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 F
+(\0502\051) 72 256.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(The global and local name space for these can be overridden with optional extra arguments.) 108 256.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 F
+(\0503\051) 72 237.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+0.86 (The) 108 237.67 P
+2 F
+2.07 (exec) 128.72 237.67 P
+1 F
+0.86 ( statement and the) 155.12 237.67 P
+2 F
+2.07 (eval\050\051) 241.07 237.67 P
+1 F
+0.86 ( and) 280.67 237.67 P
+2 F
+2.07 (execfile\050\051) 303.78 237.67 P
+1 F
+0.86 ( functions have optional arguments to) 369.78 237.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(override the global and local namespace. If only one namespace is specified, it is used for both.) 108 224.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.05 (The built-in functions) 72 199.67 B
+2 F
+0.99 0.05 (globals\050\051) 173.1 199.67 B
+1 F
+0.41 0.05 ( and) 232.95 199.67 B
+2 F
+0.99 0.05 (locals\050\051) 255.41 199.67 B
+1 F
+0.41 0.05 ( returns a dictionary representing the current global) 308.62 199.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.27 (and local name space, respectively. The effect of modifications to this dictionary on the name space are un-) 72 186.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(defined.) 72 173.67 T
+1 8.8 Q
+(1) 107.74 178.07 T
+0 0 0 1 0 0 0 K
+72 108 540 123 C
+0 0 0 1 0 0 0 K
+81 121 225 121 2 L
+0.5 H
+2 Z
+0 X
+0 0 0 1 0 0 0 K
+N
+0 0 0 1 0 0 0 K
+0 0 612 792 C
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(1.) 81 101.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.46 (The current implementations return the dictionary actually used to implement the name space,) 94.5 101.33 P
+3 11 Q
+0.5 (except) 479.29 101.33 P
+1 10 Q
+0.46 ( for) 507.38 101.33 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2.45 (functions, where the optimizer may cause the local name space to be implemented differently, and) 94.46 89.33 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(locals\050\051) 94.46 77.33 T
+1 F
+( returns a dictionary that is a shadow copy of the actual local name space.) 142.46 77.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 12 Q
+(T) 179.93 573 T
+(able 3: Name Spaces f) 186.84 573 T
+(or V) 298.52 573 T
+(arious Code Blocks) 320.41 573 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Code block type) 101.8 547 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( Global name space) 240.04 547 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( Local name space) 377.46 547 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( Notes) 487.89 547 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(Module) 78 523.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( n.s. for this module) 216.25 523.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( same as global) 370.12 523.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Script \050\336le or command\051) 78 502.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( n.s. for) 216.25 502.67 T
+2 F
+(__main__) 252.61 502.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( same as global) 370.12 502.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\0501\051) 485.77 502.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Interacti) 78 481.67 T
+(v) 114.38 481.67 T
+(e command) 119.71 481.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( n.s. for) 216.25 481.67 T
+2 F
+(__main__) 252.61 481.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( same as global) 370.12 481.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Class de\336nition) 78 460.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( global n.s. of containing block) 216.25 460.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( ne) 370.12 460.67 T
+(w n.s.) 382.98 460.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Function body) 78 439.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( global n.s. of containing block) 216.25 439.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( ne) 370.12 439.67 T
+(w n.s.) 382.98 439.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(String passed to) 78 418.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(exec) 78 405.67 T
+1 F
+( statement) 104.4 405.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( global n.s. of containing block) 216.25 418.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.47 ( local n.s. of containing) 370.12 418.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(block) 370.12 405.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( \0502\051, \0503\051) 485.77 418.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(String passed to) 78 384.67 T
+2 F
+(eval\050\051) 151.03 384.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( global n.s. of caller) 216.25 384.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( local n.s. of caller) 370.12 384.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( \0502\051, \0503\051) 485.77 384.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.3 (File read by) 78 363.67 P
+2 F
+-0.73 (execfile\050\051) 132.38 363.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( global n.s. of caller) 216.25 363.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( local n.s. of caller) 370.12 363.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( \0502\051, \0503\051) 485.77 363.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.08 (Expression read by) 78 342.67 P
+2 F
+-0.18 (input) 164.84 342.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+( global n.s. of caller) 216.25 342.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( local n.s. of caller) 370.12 342.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+72 562.75 72 335.25 2 L
+V
+0.5 H
+0 Z
+N
+210.25 563.25 210.25 334.75 2 L
+V
+N
+364.12 563.25 364.12 334.75 2 L
+V
+N
+479.77 563.25 479.77 334.75 2 L
+V
+N
+527.02 562.75 527.02 335.25 2 L
+V
+N
+71.75 563 527.27 563 2 L
+V
+N
+72.25 538.25 526.77 538.25 2 L
+V
+N
+72.25 535.75 526.77 535.75 2 L
+V
+N
+71.75 516 527.27 516 2 L
+V
+N
+71.75 495 527.27 495 2 L
+V
+N
+71.75 474 527.27 474 2 L
+V
+N
+71.75 453 527.27 453 2 L
+V
+N
+71.75 432 527.27 432 2 L
+V
+N
+71.75 398 527.27 398 2 L
+V
+N
+71.75 377 527.27 377 2 L
+V
+N
+71.75 356 527.27 356 2 L
+V
+N
+71.75 335 527.27 335 2 L
+V
+N
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "24" 30
+%%Page: "25" 31
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(25) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Execution model) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(4.2) 99 710.67 T
+(Exceptions) 135 710.67 T
+1 11 Q
+-0.22 (Exceptions are a means of breaking out of the normal flow of control of a code block in order to han-) 99 685.67 P
+0.35 (dle errors or other exceptional conditions. An exception is) 99 672.67 P
+3 F
+0.35 (raised) 360.62 672.67 P
+1 F
+0.35 ( at the point where the error is de-) 388.12 672.67 P
+1.81 (tected; it may be) 99 659.67 P
+3 F
+1.81 (handled) 181.99 659.67 P
+1 F
+1.81 ( by the surrounding code block or by any code block that directly or) 217.43 659.67 P
+(indirectly invoked the code block where the error occurred.) 99 646.67 T
+-0.29 (The Python interpreter raises an exception when it detects a run-time error \050such as division by zero\051.) 99 621.67 P
+0.19 (A Python program can also explicitly raise an exception with the) 99 608.67 P
+2 F
+0.44 (raise) 389.13 608.67 P
+1 F
+0.19 ( statement. Exception han-) 422.13 608.67 P
+0.41 0.06 (dlers are specified with the) 99 595.67 B
+2 F
+0.99 0.06 (try...except) 224.2 595.67 B
+1 F
+0.41 0.06 ( statement. The) 304.18 595.67 B
+2 F
+0.99 0.06 (try) 376.71 595.67 B
+1 F
+0.41 0.06 (...) 396.7 595.67 B
+2 F
+0.99 0.06 (finally) 405.15 595.67 B
+1 F
+0.41 0.06 ( statement specifies) 451.8 595.67 B
+-0.09 (cleanup code which does not handle the exception, but is executed whether an exception occurred or) 99 582.67 P
+(not in the preceding code.) 99 569.67 T
+0.13 (Python uses the \322termination\323 model of error handling: an exception handler can find out what hap-) 99 544.67 P
+-0.33 (pened and continue execution at an outer level, but it cannot repair the cause of the error and retry the) 99 531.67 P
+(failing operation \050except by re-entering the the offending piece of code from the top\051.) 99 518.67 T
+0.41 0.01 (When an exception is not handled at all, the interpreter terminates execution of the program, or re-) 99 493.67 B
+(turns to its interactive main loop. In this case, the interpreter normally prints a stack backtrace.) 99 480.67 T
+-0.42 (Exceptions are identified by string objects or class instances. Selection of a matching) 99 455.67 P
+2 F
+-1 (except) 470.58 455.67 P
+1 F
+-0.42 ( clause) 510.18 455.67 P
+-0.39 (is based on object identity \050i.e. two different string objects with the same value represent different ex-) 99 442.67 P
+-0.46 (ceptions\051. For string exceptions, the except clause must reference the same string object. For class ex-) 99 429.67 P
+(ceptions, the except clause must reference the same class or a base class of it.) 99 416.67 T
+0.41 0.05 (When an exception is raised, an object \050maybe) 99 391.67 B
+2 F
+0.99 0.05 (None) 312.57 391.67 B
+1 F
+0.41 0.05 (\051 is passed as the exception\325s \322parameter\323 or) 339.17 391.67 B
+-0.47 (\324\324value\325\325; this object does not affect the selection of an exception handler, but is passed to the selected) 99 378.67 P
+0.16 (exception handler as additional information. For class exceptions, this object must be an instance of) 99 365.67 P
+(the exception class being raised.) 99 352.67 T
+(See also the description of the) 99 327.67 T
+2 F
+(try) 234.04 327.67 T
+1 F
+( and) 253.84 327.67 T
+2 F
+(raise) 275.22 327.67 T
+1 F
+( statements in \322Compound statements\323 on page) 308.22 327.67 T
+(45.) 519.34 327.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "25" 31
+%%Page: "26" 32
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(26) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "26" 32
+%%Page: "27" 33
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(27) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Expressions) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 16 Q
+(C) 99 709.33 T
+0 12.8 Q
+(HAPTER) 110.55 709.33 T
+0 16 Q
+(5:) 167.62 709.33 T
+(E) 198 709.33 T
+0 12.8 Q
+(XPRESSIONS) 208.67 709.33 T
+1 11 Q
+(This chapter explains the meaning of the elements of expressions in Python.) 99 672.67 T
+4 F
+-0.53 (Syntax notes:) 99 653.67 P
+1 F
+-0.53 ( in this and the following chapters, extended BNF notation will be used to describe syn-) 161.72 653.67 P
+(tax, not lexical analysis. When \050one alternative of\051 a syntax rule has the form) 99 640.67 T
+2 10 Q
+(name:    othername) 99 622.33 T
+1 11 Q
+(and no semantics are given, the semantics of this form of) 99 597.67 T
+2 F
+(name) 352.57 597.67 T
+1 F
+( are the same as for) 378.97 597.67 T
+2 F
+(othername) 466.94 597.67 T
+1 F
+(.) 526.34 597.67 T
+0 14 Q
+(5.1) 99 570.67 T
+(Arithmetic conversions) 135 570.67 T
+1 11 Q
+-0.15 (When a description of an arithmetic operator below uses the phrase \322the numeric arguments are con-) 99 545.67 P
+0.86 (verted to a common type\323, the arguments are coerced using the coercion rules listed at the end of) 99 532.67 P
+(chapter 3. If both arguments are standard numeric types, the following coercions are applied:) 99 519.67 T
+(\245) 99 500.67 T
+(If either argument is a complex number, the other is converted to complex;) 113.4 500.67 T
+(\245) 99 481.67 T
+(otherwise, if either argument is a floating point number, the other is converted to floating point;) 113.4 481.67 T
+(\245) 99 462.67 T
+(otherwise, if either argument is a long integer, the other is converted to long integer;) 113.4 462.67 T
+(\245) 99 443.67 T
+(otherwise, both must be plain integers and no conversion is necessary.) 113.4 443.67 T
+-0.13 (Some additional rules apply for certain operators \050e.g. a string left argument to the \324) 99 418.67 P
+2 F
+-0.32 (%) 465.56 418.67 P
+1 F
+-0.13 (\325 operator\051. Ex-) 472.16 418.67 P
+(tensions can define their own coercions.) 99 405.67 T
+0 14 Q
+(5.2) 99 378.67 T
+(Atoms) 135 378.67 T
+1 11 Q
+1.43 (Atoms are the most basic elements of expressions. The simplest atoms are identifiers or literals.) 99 353.67 P
+0.1 (Forms enclosed in reverse quotes or in parentheses, brackets or braces are also categorized syntacti-) 99 340.67 P
+(cally as atoms. The syntax for atoms is:) 99 327.67 T
+2 10 Q
+(atom:      identifier | literal | enclosure) 99 309.33 T
+(enclosure: parenth_form|list_display|dict_display|string_conversion) 99 297.33 T
+0 12 Q
+(5.2.1) 99 272 T
+(Identifiers \050Names\051) 144 272 T
+1 11 Q
+-0.25 (An identifier occurring as an atom is a reference to a local, global or built-in name binding. If a name) 99 252.67 P
+1.68 (is assigned to anywhere in a code block \050even in unreachable code\051, and is not mentioned in a) 99 239.67 P
+2 F
+-1.17 (global) 99 226.67 P
+1 F
+-0.49 ( statement in that code block, then it refers to a local name throughout that code block. When) 138.6 226.67 P
+0.83 (it is not assigned to anywhere in the block, or when it is assigned to but also explicitly listed in a) 99 213.67 P
+2 F
+0.64 (global) 99 200.67 P
+1 F
+0.27 ( statement, it refers to a global name if one exists, else to a built-in name \050and this binding) 138.6 200.67 P
+(may dynamically change\051.) 99 187.67 T
+0.14 (When the name is bound to an object, evaluation of the atom yields that object. When a name is not) 99 168.67 P
+(bound, an attempt to evaluate it raises a) 99 155.67 T
+2 F
+(NameError) 275.89 155.67 T
+1 F
+( exception) 335.29 155.67 T
+0 12 Q
+(5.2.2) 99 130 T
+(Literals) 144 130 T
+1 11 Q
+(Python supports string literals and various numeric literals:) 99 110.67 T
+2 10 Q
+-0.82 (literal:   stringliteral | integer | longinteger | floatnumber | imagnumber) 99 92.33 P
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "27" 33
+%%Page: "28" 34
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(28) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.35 (Evaluation of a literal yields an object of the given type \050string, integer, long integer, floating point) 99 712.67 P
+-0.2 (number, complex number\051 with the given value. The value may be approximated in the case of float-) 99 699.67 P
+(ing point and imaginary \050complex\051 literals.  \050See \322Literals\323 on page) 99 686.67 T
+(6 for details.\051) 399 686.67 T
+-0.13 (All literals correspond to immutable data types, and hence the object\325s identity is less important than) 99 661.67 P
+0.01 (its value. Multiple evaluations of literals with the same value \050either the same occurrence in the pro-) 99 648.67 P
+0.41 0 (gram text or a different occurrence\051 may obtain the same object or a different object with the same) 99 635.67 B
+(value.) 99 622.67 T
+-0.3 (\050In the original implementation, all literals in the same code block with the same type and value yield) 99 597.67 P
+(the same object.\051) 99 584.67 T
+0 12 Q
+(5.2.3) 99 559 T
+(Parenthesized forms) 144 559 T
+1 11 Q
+(A parenthesized form is an optional expression list enclosed in parentheses:) 99 539.67 T
+2 10 Q
+(parenth_form:      "\050" [expression_list] "\051") 99 521.33 T
+1 11 Q
+-0.03 (A parenthesized expression list yields whatever that expression list yields: if the list contains at least) 99 496.67 P
+0.18 (one comma, it yields a tuple; otherwise, it yields the single expression that makes up the expression) 99 483.67 P
+(list.) 99 470.67 T
+0.07 (An empty pair of parentheses yields an empty tuple object. Since tuples are immutable, the rules for) 99 445.67 P
+(literals apply\050i.e., two occurrences of the empty tuple may or may not yield the same object\051.) 99 432.67 T
+-0.08 (Note that tuples are not formed by the parentheses, but rather by use of the comma operator. The ex-) 99 407.67 P
+-0.53 (ception is the empty tuple, for which parentheses) 99 394.67 P
+3 F
+-0.53 (are) 313.21 394.67 P
+1 F
+-0.53 ( required \321 allowing unparenthesized \322nothing\323) 327.88 394.67 P
+(in expressions would cause ambiguities and allow common typos to pass uncaught.) 99 381.67 T
+0 12 Q
+(5.2.4) 99 356 T
+(List displays) 144 356 T
+1 11 Q
+(A list display is a possibly empty series of expressions enclosed in square brackets:) 99 336.67 T
+2 10 Q
+(list_display:   "[" [expression_list] "]") 99 318.33 T
+1 11 Q
+0.16 (A list display yields a new list object. If it has no expression list, the list object has no items. Other-) 99 293.67 P
+-0.06 (wise, the elements of the expression list are evaluated from left to right and inserted in the list object) 99 280.67 P
+(in that order.) 99 267.67 T
+0 12 Q
+(5.2.5) 99 242 T
+(Dictionary displays) 144 242 T
+1 11 Q
+(A dictionary display is a possibly empty series of key/datum pairs enclosed in curly braces:) 99 222.67 T
+2 10 Q
+(dict_display:   "{" [key_datum_list] "}") 99 204.33 T
+(key_datum_list: key_datum \050"," key_datum\051* [","]) 99 192.33 T
+(key_datum:      expression ":" expression) 99 180.33 T
+1 11 Q
+(A dictionary display yields a new dictionary object) 99 155.67 T
+0.19 (The key/datum pairs are evaluated from left to right to define the entries of the dictionary: each key) 99 130.67 P
+(object is used as a key into the dictionary to store the corresponding datum.) 99 117.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "28" 34
+%%Page: "29" 35
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(29) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Expressions) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.41 0.14 (Restrictions on the types of the key values are listed earlier in \322The standard type hierarchy\323 on) 99 712.67 B
+-0.19 (page) 99 699.67 P
+-0.19 (12 \050to summarize, the key type should be hashable, which excludes all mutable objects\051. Clash-) 122.52 699.67 P
+0.09 (es between duplicate keys are not detected; the last datum \050textually rightmost in the display\051 stored) 99 686.67 P
+(for a given key value prevails.) 99 673.67 T
+0 12 Q
+(5.2.6) 99 648 T
+(String conversions) 144 648 T
+1 11 Q
+(A string conversion is an expression list enclosed in reverse \050a.k.a. backward\051 quotes:) 99 628.67 T
+2 10 Q
+(string_conversion: "\324" expression_list "\324") 99 610.33 T
+1 11 Q
+0.41 0.04 (A string conversion evaluates the contained expression list and converts the resulting object into a) 99 585.67 B
+(string according to rules specific to its type.) 99 572.67 T
+0.12 (If the object is a string, a number,) 99 547.67 P
+2 F
+0.29 (None) 250.87 547.67 P
+1 F
+0.12 (, or a tuple, list or dictionary containing only objects whose) 277.27 547.67 P
+-0.27 (type is one of these, the resulting string is a valid Python expression which can be passed to the built-) 99 534.67 P
+0.41 0.11 (in function) 99 521.67 B
+2 F
+0.99 0.11 (eval\050\051) 151.84 521.67 B
+1 F
+0.41 0.11 ( to yield an expression with the same value \050or an approximation, if floating) 192.09 521.67 B
+(point numbers are involved\051.) 99 508.67 T
+-0.29 (\050In particular, converting a string adds quotes around it and converts \322funny\323 characters to escape se-) 99 483.67 P
+(quences that are safe to print.\051) 99 470.67 T
+-0.17 (It is illegal to attempt to convert recursive objects \050e.g. lists or dictionaries that contain a reference to) 99 445.67 P
+(themselves, directly or indirectly.\051) 99 432.67 T
+0.21 (The built-in function) 99 407.67 P
+2 F
+0.51 (repr\050\051) 194.06 407.67 P
+1 F
+0.21 ( performs exactly the same conversion in its argument as enclosing it) 233.66 407.67 P
+0.41 0.07 (in parentheses and reverse quotes does. The built-in function) 99 394.67 B
+2 F
+0.99 0.07 (str\050\051) 377.08 394.67 B
+1 F
+0.41 0.07 ( performs a similar but more) 410.43 394.67 B
+(user-friendly conversion.) 99 381.67 T
+0 14 Q
+(5.3) 99 354.67 T
+(Primaries) 135 354.67 T
+1 11 Q
+(Primaries represent the most tightly bound operations of the language. Their syntax is:) 99 329.67 T
+2 10 Q
+(primary:        atom | attributeref | subscription | slicing | call) 99 311.33 T
+0 12 Q
+(5.3.1) 99 286 T
+(Attribute references) 144 286 T
+1 11 Q
+(An attribute reference is a primary followed by a period and a name:) 99 266.67 T
+2 10 Q
+(attributeref:   primary "." identifier) 99 248.33 T
+1 11 Q
+-0.33 (The primary must evaluate to an object of a type that supports attribute references. This object is then) 99 223.67 P
+-0.42 (asked to produce the attribute whose name is the identifier. If this attribute is not available, the excep-) 99 210.67 P
+0.41 0.08 (tion) 99 197.67 B
+2 F
+0.99 0.08 (AttributeError) 119.68 197.67 B
+1 F
+0.41 0.08 ( is raised. Otherwise, the type and value of the object produced is deter-) 213.21 197.67 B
+-0.19 (mined by the object. Multiple evaluations of the same attribute reference may yield different objects.) 99 184.67 P
+0 12 Q
+(5.3.2) 99 159 T
+(Subscriptions) 144 159 T
+1 11 Q
+(A subscription selects an item of a sequence \050string, tuple or list\051 or mapping \050dictionary\051 object:) 99 139.67 T
+2 10 Q
+(subscription:   primary "[" expression_list "]") 99 121.33 T
+1 11 Q
+(The primary must evaluate to an object of a sequence or mapping type.) 99 96.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "29" 35
+%%Page: "30" 36
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(30) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.22 (If the primary is a mapping, the expression list must evaluate to an object whose value is one of the) 99 712.67 P
+0.41 0.01 (keys of the mapping, and the subscription selects the value in the mapping that corresponds to that) 99 699.67 B
+(key.) 99 686.67 T
+-0.22 (If the primary is a sequence, the expression \050list\051 must evaluate to a plain integer. If this value is neg-) 99 661.67 P
+-0.18 (ative, the length of the sequence is added to it \050so that, e.g.) 99 648.67 P
+2 F
+-0.42 (x[-1]) 357.31 648.67 P
+1 F
+-0.18 ( selects the last item of) 390.31 648.67 P
+2 F
+-0.42 (x) 492.52 648.67 P
+1 F
+-0.18 (.\051 The re-) 499.12 648.67 P
+0.41 0.03 (sulting value must be a nonnegative integer less than the number of items in the sequence, and the) 99 635.67 B
+(subscription selects the item whose index is that value \050counting from zero\051.) 99 622.67 T
+-0.42 (A string\325s items are characters. A character is not a separate data type but a string of exactly one char-) 99 597.67 P
+(acter.) 99 584.67 T
+0 12 Q
+(5.3.3) 99 559 T
+(Slicings) 144 559 T
+1 11 Q
+0.14 (A slicing selects a range of items in a sequence \050string, tuple or list\051 object. Slicings may be used as) 99 539.67 P
+(expressions or as targets in assignment or) 99 526.67 T
+2 F
+(del) 284.45 526.67 T
+1 F
+( statements.  The syntax for a slicing:) 304.25 526.67 T
+2 10 Q
+(slicing:          simple_slicing | extended_slicing) 99 508.33 T
+(simple_slicing:   primary "[" short_slice "]") 99 496.33 T
+(extended_slicing: primary "[" slice_list "]") 99 484.33 T
+(slice_list:       slice_item \050"," slice_item\051* [","]) 99 472.33 T
+(slice_item:       expression | proper_slice | ellipses) 99 460.33 T
+(proper_slice:     short_slice | long_slice) 99 448.33 T
+(short_slice:      [lower_bound] ":" [upper_bound]) 99 436.33 T
+(long_slice:       short_slice ":" [stride]) 99 424.33 T
+(lower_bound:      expression) 99 412.33 T
+(upper_bound:      expression) 99 400.33 T
+(stride:           expression) 99 388.33 T
+(ellipses:         "...") 99 376.33 T
+1 11 Q
+-0.09 (There\325s an ambiguity in the formal syntax here: anything that looks like an expression list also looks) 99 351.67 P
+0.3 (like a slice list, so any subscription can be interpreted as a slicing. Rather than further complicating) 99 338.67 P
+0.41 0.09 (the syntax, this is disambiguated by declaring that in this case the interpretation as a subscription) 99 325.67 B
+0.41 0.03 (takes priority over the interpretation as a slicing \050this is the case if the slice list contains no proper) 99 312.67 B
+-0.37 (slice nor ellipses\051. Similarly, when the slice list has exactly one short slice and no trailing comma, the) 99 299.67 P
+(interpretation as a simple slicing takes priority over that as an extended slicing.) 99 286.67 T
+0.41 0.02 (The semantics for a simple slicing are as follows. The primary must evaluate to a sequence object.) 99 261.67 B
+0.01 (The lower and upper bound expressions, if present, must evaluate to plain integers; defaults are zero) 99 248.67 P
+-0.17 (and the sequence\325s length, respectively. If either bound is negative, the sequence\325s length is added to) 99 235.67 P
+0.38 (it. The slicing now selects all items with index) 99 222.67 P
+3 F
+0.38 (k) 309.58 222.67 P
+1 F
+0.38 ( such that) 314.46 222.67 P
+3 F
+0.38 (i) 360.51 222.67 P
+1 F
+0.38 ( <=) 363.57 222.67 P
+3 F
+0.38 (k) 382.23 222.67 P
+1 F
+0.38 ( <) 387.12 222.67 P
+3 F
+0.38 (j) 399.58 222.67 P
+1 F
+0.38 ( where) 402.64 222.67 P
+3 F
+0.38 (i) 435.77 222.67 P
+1 F
+0.38 ( and) 438.83 222.67 P
+3 F
+0.38 (j) 460.97 222.67 P
+1 F
+0.38 ( are the specified) 464.03 222.67 P
+0.41 0.06 (lower and upper bounds. This may be an empty sequence. It is not an error if) 99 209.67 B
+3 F
+0.41 0.06 (i) 451.37 209.67 B
+1 F
+0.41 0.06 ( or) 454.49 209.67 B
+3 F
+0.41 0.06 (j) 470.23 209.67 B
+1 F
+0.41 0.06 ( lie outside the) 473.35 209.67 B
+(range of valid indexes \050such items don\325t exist so they aren\325t selected\051.) 99 196.67 T
+-0.35 (The semantics for an extended slicing are as follows. The primary must evaluate to a mapping object,) 99 171.67 P
+-0.01 (and it is indexed with a key that is constructed from the slice list, as follows. If the slice list contains) 99 158.67 P
+-0.42 (at least one comma, the key is a tuple containing the conversion of the slice items; otherwise, the con-) 99 145.67 P
+-0.39 (version of the lone slice item is the key. The conversion of a slice item that is an expression is that ex-) 99 132.67 P
+0.32 (pression. The conversion of an ellipses slice item is the built-in) 99 119.67 P
+2 F
+0.76 (Ellipses) 382.99 119.67 P
+1 F
+0.32 ( object. The conversion) 435.79 119.67 P
+-0.22 (of a proper slice is a slice object \050see page) 99 106.67 P
+-0.22 (17\051 whose) 285.15 106.67 P
+2 F
+-0.54 (start) 332.97 106.67 P
+1 F
+-0.22 (,) 365.97 106.67 P
+2 F
+-0.54 (stop) 371.24 106.67 P
+1 F
+-0.22 ( and) 397.64 106.67 P
+2 F
+-0.54 (step) 418.58 106.67 P
+1 F
+-0.22 ( attributes are the val-) 444.98 106.67 P
+-0.31 (ues of the expressions given as lower bound, upper bound and stride, respectively, substituting) 99 93.67 P
+2 F
+-0.73 (None) 513.6 93.67 P
+1 F
+(for missing expressions.) 99 80.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "30" 36
+%%Page: "31" 37
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(31) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Expressions) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+(5.3.4) 99 712 T
+(Calls) 144 712 T
+1 11 Q
+(A call calls a callable object \050e.g. a function\051 with a possibly empty series of arguments:) 99 692.67 T
+2 10 Q
+(call:                 primary "\050" [argument_list [","]] "\051") 99 674.33 T
+(argument_list:        positional_arguments ["," keyword_arguments]) 99 662.33 T
+(                    | keyword_arguments) 99 650.33 T
+(positional_arguments: expression \050"," expression\051*) 99 638.33 T
+(keyword_arguments:    keyword_item \050"," keyword_item\051*) 99 626.33 T
+(keyword_item:         identifier "=" expression) 99 614.33 T
+1 11 Q
+(A trailing comma may be present after an argument list but does not affect the semantics.) 99 589.67 T
+-0.32 (The primary must evaluate to a callable object \050user-defined functions, built-in functions, methods of) 99 564.67 P
+0.22 (built-in objects, class objects, methods of class instances, and certain class instances themselves are) 99 551.67 P
+-0.15 (callable; extensions may define additional callable object types\051.  All argument expressions are eval-) 99 538.67 P
+-0.05 (uated before the call is attempted. Please refer to \322Function definitions\323 on page) 99 525.67 P
+-0.05 (48 for the syntax of) 454.04 525.67 P
+(formal parameter lists.) 99 512.67 T
+0.08 (If keyword arguments are present, they are first converted to positional arguments, as follows. First,) 99 487.67 P
+0.3 (a list of unfilled slots is created for the formal parameters. If there are N positional arguments, they) 99 474.67 P
+-0.47 (are placed in the first N slots. Next, for each keyword argument, the identifier is used to determine the) 99 461.67 P
+0.41 0.06 (corresponding slot \050if the identifier is the same as the first formal parameter name, the first slot is) 99 448.67 B
+-0.16 (used, and so on\051. If the slot is already filled, a) 99 435.67 P
+2 F
+-0.38 (TypeError) 300.71 435.67 P
+1 F
+-0.16 ( exception is raised. Otherwise, the value) 360.11 435.67 P
+-0.06 (of the argument is placed in the slot, filling it \050even if the expression is) 99 422.67 P
+2 F
+-0.15 (None) 412.16 422.67 P
+1 F
+-0.06 (, it fills the slot\051. When) 438.56 422.67 P
+-0.52 (all arguments have been processed, the slots that are still unfilled are filled with the corresponding de-) 99 409.67 P
+-0.38 (fault value from the function definition. \050Default values are calculated, once, when the function is de-) 99 396.67 P
+0.41 0.04 (fined; thus, a mutable object such as a list or dictionary used as default value will be shared by all) 99 383.67 B
+-0.3 (calls that don\325t specify an argument value for the corresponding slot; this should usually be avoided.\051) 99 370.67 P
+0.41 0.08 (If there are any unfilled slots for which no default value is specified, a) 99 357.67 B
+2 F
+0.99 0.08 (TypeError) 422.4 357.67 B
+1 F
+0.41 0.08 ( exception is) 482.56 357.67 B
+(raised. Otherwise, the list of filled slots is used as the argument list for the call.) 99 344.67 T
+0.27 (If there are more positional arguments than there are formal parameter slots, a) 99 319.67 P
+2 F
+0.64 (TypeError) 448.27 319.67 P
+1 F
+0.27 ( excep-) 507.67 319.67 P
+0.13 (tion is raised, unless a formal parameter using the syntax\324\324) 99 306.67 P
+2 F
+0.31 (*identifier) 357.39 306.67 P
+1 F
+0.13 (\325\325 is present; in this case,) 429.99 306.67 P
+-0.05 (that formal parameter receives a tuple containing the excess positional arguments \050or an empty tuple) 99 293.67 P
+(if there were no excess positional arguments\051.) 99 280.67 T
+-0.3 (If any keyword argument does not correspond to a formal parameter name, a) 99 255.67 P
+2 F
+-0.72 (TypeError) 435.38 255.67 P
+1 F
+-0.3 ( exception) 494.78 255.67 P
+-0.46 (is raised, unless a formal parameter using the syntax \324\324) 99 242.67 P
+2 F
+-1.11 (**identifier) 334.95 242.67 P
+1 F
+-0.46 (\325\325 is present; in this case, that) 414.15 242.67 P
+0.41 0.12 (formal parameter receives a dictionary containing the excess keyword arguments \050using the key-) 99 229.67 B
+-0.33 (words as keys and the argument values as corresponding values\051, or a \050new\051 empty dictionary if there) 99 216.67 P
+(were no excess keyword arguments.) 99 203.67 T
+0.41 0.01 (Formal parameters using the syntax \324\324) 99 178.67 B
+2 F
+0.99 0.01 (*identifier) 268.55 178.67 B
+1 F
+0.41 0.01 (\325\325 or \324\324) 341.26 178.67 B
+2 F
+0.99 0.01 (**identifier) 371.48 178.67 B
+1 F
+0.41 0.01 (\325\325 cannot be used as) 450.8 178.67 B
+0.41 0.25 (positional argument slots or as keyword argument names. Formal parameters using the syntax) 99 165.67 B
+-0.14 (\324\324) 99 152.67 P
+2 F
+-0.33 (\050sublist\051) 106.33 152.67 P
+1 F
+-0.14 (\325\325 cannot be used as keyword argument names; the outermost sublist corresponds to a) 165.73 152.67 P
+-0.18 (single unnamed argument slot, and the argument value is assigned to the sublist using the usual tuple) 99 139.67 P
+(assignment rules after all other parameter processing is done.) 99 126.67 T
+0.41 0.07 (A call always returns some value, possibly) 99 101.67 B
+2 F
+0.99 0.07 (None) 295.6 101.67 B
+1 F
+0.41 0.07 (, unless it raises an exception. How this value is) 322.28 101.67 B
+(computed depends on the type of the callable object.) 99 88.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "31" 37
+%%Page: "32" 38
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(32) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(If it is:) 99 712.67 T
+4 F
+(a user-defined function:) 99 693.67 T
+1 F
+-0.41 (the code block for the function is executed, passing it the argument list. The) 211.44 693.67 P
+0.3 (first thing the code block will do is bind the formal parameters to the arguments; this is de-) 135 680.67 P
+0.74 (scribed in section\322Function definitions\323 on page) 135 667.67 P
+0.74 (48. When the code block executes a) 354.38 667.67 P
+2 F
+1.76 (re-) 520.2 667.67 P
+(turn) 135 654.67 T
+1 F
+( statement, this specifies the return value of the function call.) 161.4 654.67 T
+4 F
+(a built-in function or method:) 99 635.67 T
+1 F
+-0.17 (the result is up to the interpreter; see the library reference manual for) 238.95 635.67 P
+(the descriptions of built-in functions and methods.) 135 622.67 T
+4 F
+(a class object:) 99 603.67 T
+1 F
+(a new instance of that class is returned.) 164.37 603.67 T
+4 F
+(a class instance method:) 99 584.67 T
+1 F
+-0.57 (the corresponding user-defined function is called, with an argument list that) 212.35 584.67 P
+(is one longer than the argument list of the call. The instance becomes the first argument.) 135 571.67 T
+0 14 Q
+(5.4) 99 544.67 T
+(The power operator) 135 544.67 T
+1 11 Q
+-0.32 (The power operator binds more tightly than unary operators on its left; it binds less tightly than unary) 99 515.67 P
+(operators on its right. The syntax is:) 99 502.67 T
+2 10 Q
+(power:         primary ["**" u_expr]) 99 484.33 T
+1 11 Q
+-0.4 (Thus, in an unparenthesized sequence of power and unary operators, the operators are evaluated from) 99 459.67 P
+(right to left \050this does not constrain the evaluation order for the operands\051.) 99 446.67 T
+-0.32 (The power operator has the same semantics as the built-in) 99 421.67 P
+2 F
+-0.76 (pow\050\051) 353.68 421.67 P
+1 F
+-0.32 ( function: it yields its left argument) 386.68 421.67 P
+0.41 0.05 (raised to the power of its right argument. The numeric arguments are first converted to a common) 99 408.67 B
+-0.33 (type. The result type is that of the arguments after coercion; if the result is not expressible in that type) 99 395.67 P
+-0.08 (\050as in raising an integer to a negative power, or a negative floating point number to a broken power\051,) 99 382.67 P
+(a) 99 369.67 T
+2 F
+(TypeError) 106.63 369.67 T
+1 F
+( exception is raised.) 166.03 369.67 T
+0 14 Q
+(5.5) 99 342.67 T
+(Unary arithmetic operations) 135 342.67 T
+1 11 Q
+(All unary arithmetic \050and bit-wise\051 operations have the same priority:) 99 317.67 T
+2 10 Q
+(u_expr:         power | "-" u_expr | "+" u_expr | "~" u_expr) 99 299.33 T
+1 11 Q
+(The unary) 99 274.67 T
+2 F
+("-") 146.65 274.67 T
+1 F
+( \050minus\051 operator yields the negation of its numeric argument.) 166.45 274.67 T
+(The unary) 99 249.67 T
+2 F
+("+") 146.65 249.67 T
+1 F
+( \050plus\051 operator yields its numeric argument unchanged.) 166.45 249.67 T
+0.41 0.01 (The unary) 99 224.67 B
+2 F
+0.99 0.01 ("~") 147.55 224.67 B
+1 F
+0.41 0.01 ( \050invert\051 operator yields the bit-wise inversion of its plain or long integer argument.) 167.37 224.67 B
+(The bit-wise inversion of) 99 211.67 T
+2 F
+(x) 212.65 211.67 T
+1 F
+( is defined as) 219.25 211.67 T
+2 F
+(-\050x+1\051) 279.74 211.67 T
+1 F
+(. It only applies to integral numbers.) 319.34 211.67 T
+(In all three cases, if the argument does not have the proper type, a) 99 186.67 T
+2 F
+(TypeError) 391.04 186.67 T
+1 F
+( exception is raised.) 450.44 186.67 T
+0 14 Q
+(5.6) 99 159.67 T
+(Binary arithmetic operations) 135 159.67 T
+1 11 Q
+0.18 (The remaining binary arithmetic operations have the conventional priority levels. Note that some of) 99 134.67 P
+0.65 (these operations also apply to certain non-numeric types. Apart from the power operator, there are) 99 121.67 P
+(only two levels, one for multiplicative operators and one for additive operators:) 99 108.67 T
+2 10 Q
+(m_expr:         u_expr | m_expr "*" u_expr) 99 90.33 T
+(              | m_expr "/" u_expr | m_expr "%" u_expr) 99 78.33 T
+(a_expr:         m_expr | aexpr "+" m_expr | aexpr "-" m_expr) 99 66.33 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "32" 38
+%%Page: "33" 39
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(33) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Expressions) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.45 (The ") 99 712.67 P
+2 F
+-1.08 (*) 122.89 712.67 P
+1 F
+-0.45 (" \050multiplication\051 operator yields the product of its arguments. The arguments must either both) 129.49 712.67 P
+-0.12 (be numbers, or one argument must be a plain integer and the other must be a sequence. In the former) 99 699.67 P
+-0.29 (case, the numbers are converted to a common type and then multiplied together. In the latter case, se-) 99 686.67 P
+(quence repetition is performed; a negative repetition factor yields an empty sequence.) 99 673.67 T
+-0.4 (The ") 99 648.67 P
+2 F
+-0.95 (/) 122.95 648.67 P
+1 F
+-0.4 (" \050division\051 operator yields the quotient of its arguments. The numeric arguments are first con-) 129.55 648.67 P
+0.04 (verted to a common type. Plain or long integer division yields an integer of the same type; the result) 99 635.67 P
+-0.22 (is that of mathematical division with the \324floor\325 function applied to the result. Division by zero raises) 99 622.67 P
+(the) 99 609.67 T
+2 F
+(ZeroDivisionError) 115.19 609.67 T
+1 F
+( exception) 227.39 609.67 T
+-0.47 (The ") 99 584.67 P
+2 F
+-1.12 (%) 122.88 584.67 P
+1 F
+-0.47 (" \050modulo\051 operator yields the remainder from the division of the first argument by the second.) 129.48 584.67 P
+0.41 0.21 (The numeric arguments are first converted to a common type. A zero right argument raises the) 99 571.67 B
+2 F
+-0.63 (ZeroDivisionError) 99 558.67 P
+1 F
+-0.26 ( exception. The arguments may be floating point numbers, e.g.) 211.2 558.67 P
+2 F
+-0.63 (3.14%0.7) 487.2 558.67 P
+1 F
+0.34 (equals) 99 545.67 P
+2 F
+0.83 (0.34) 130.2 545.67 P
+1 F
+0.34 ( \050since) 156.6 545.67 P
+2 F
+0.83 (3.14) 189.06 545.67 P
+1 F
+0.34 ( equals) 215.46 545.67 P
+2 F
+0.83 (4*0.7+0.34) 249.75 545.67 P
+1 F
+0.34 (\051. The modulo operator always yields a result with) 315.75 545.67 P
+0.16 (the same sign as its second operand \050or zero\051; the absolute value of the result is strictly smaller than) 99 532.67 P
+(the second operand.) 99 519.67 T
+-0.4 (The integer division and modulo operators are connected by the following identity:) 99 494.67 P
+2 F
+-0.95 (x == \050x/y\051*y) 462.7 494.67 P
+0.99 0.04 (+ \050x%y\051) 99 481.67 B
+1 F
+0.41 0.04 (. Integer division and modulo are also connected with the built-in function) 146.44 481.67 B
+2 F
+0.99 0.04 (divmod\050\051) 483.81 481.67 B
+1 F
+0.41 0.04 (:) 536.9 481.67 B
+2 F
+0.99 0.02 (divmod\050x, y\051 == \050x/y, x%y\051) 99 468.67 B
+1 F
+0.41 0.02 (. These identities don\325t hold for floating point and complex) 274.99 468.67 B
+(numbers; there a similar identity holds where) 99 455.67 T
+2 F
+(x/y) 300.95 455.67 T
+1 F
+( is replaced by) 320.75 455.67 T
+2 F
+(floor\050x/y\051) 387.34 455.67 T
+1 F
+(\051 or) 453.34 455.67 T
+2 F
+(floor\050\050x/y\051.real\051) 99 442.67 T
+1 F
+(, respectively.) 211.2 442.67 T
+-0.54 (The) 99 417.67 P
+2 F
+-1.3 ("+") 118.31 417.67 P
+1 F
+-0.54 ( \050addition\051 operator yields the sum of its arguments. The arguments must either both be num-) 138.11 417.67 P
+-0.23 (bers, or both sequences of the same type. In the former case, the numbers are converted to a common) 99 404.67 P
+(type and then added together. In the latter case, the sequences are concatenated.) 99 391.67 T
+0.41 0.05 (The) 99 366.67 B
+2 F
+0.99 0.05 ("-") 119.49 366.67 B
+1 F
+0.41 0.05 ( \050subtraction\051 operator yields the difference of its arguments. The numeric arguments are) 139.45 366.67 B
+(first converted to a common type.) 99 353.67 T
+0 14 Q
+(5.7) 99 326.67 T
+(Shifting operations) 135 326.67 T
+1 11 Q
+(The shifting operations have lower priority than the arithmetic operations:) 99 301.67 T
+2 10 Q
+(shift_expr:     a_expr | shift_expr \050 "<<" | ">>" \051 a_expr) 99 283.33 T
+1 11 Q
+0.36 (These operators accept plain or long integers as arguments. The arguments are converted to a com-) 99 258.67 P
+0.04 (mon type. They shift the first argument to the left or right by the number of bits given by the second) 99 245.67 P
+(argument.) 99 232.67 T
+0.2 (A right shift by) 99 207.67 P
+3 F
+0.2 (n) 170.07 207.67 P
+1 F
+0.2 ( bits is defined as division by) 175.57 207.67 P
+2 F
+0.48 (pow\0502,) 308.05 207.67 P
+1 F
+0.2 (n\051. A left shift by) 347.65 207.67 P
+3 F
+0.2 (n) 427.48 207.67 P
+1 F
+0.2 ( bits is defined as multi-) 432.98 207.67 P
+-0.34 (plication with) 99 194.67 P
+2 F
+-0.83 (pow\0502,) 161.87 194.67 P
+1 F
+-0.34 (n\051; for plain integers there is no overflow check so this drops bits and flips the) 201.47 194.67 P
+0.19 (sign if the result is not less than) 99 181.67 P
+2 F
+0.46 (pow\0502,31\051) 242.3 181.67 P
+1 F
+0.19 ( in absolute value. Negative shift counts raise a) 301.7 181.67 P
+2 F
+0.46 (Val-) 513.6 181.67 P
+(ueError) 99 168.67 T
+1 F
+( exception.) 145.2 168.67 T
+0 14 Q
+(5.8) 99 141.67 T
+(Binary bit-wise operations) 135 141.67 T
+1 11 Q
+(Each of the three bitwise operations has a different priority level:) 99 116.67 T
+2 10 Q
+(and_expr:       shift_expr | and_expr "&" shift_expr) 99 98.33 T
+(xor_expr:       and_expr | xor_expr "^" and_expr) 99 86.33 T
+(or_expr:       xor_expr | or_expr "|" xor_expr) 99 74.33 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "33" 39
+%%Page: "34" 40
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(34) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.41 0.03 (The) 76.5 712.67 B
+2 F
+0.99 0.03 ("&") 96.88 712.67 B
+1 F
+0.41 0.03 ( operator yields the bit-wise AND of its arguments, which must be plain or long integers.) 116.77 712.67 B
+(The arguments are converted to a common type.) 76.5 699.67 T
+0.41 0 (The) 76.5 674.67 B
+2 F
+0.99 0 ("^") 96.77 674.67 B
+1 F
+0.41 0 ( operator yields the bitwise XOR \050exclusive OR\051 of its arguments, which must be plain or) 116.57 674.67 B
+(long integers. The arguments are converted to a common type.) 76.5 661.67 T
+-0.17 (The) 76.5 636.67 P
+2 F
+-0.41 ("|") 96.19 636.67 P
+1 F
+-0.17 ( operator yields the bitwise \050inclusive\051 OR of its arguments, which must be plain or long in-) 115.99 636.67 P
+(tegers. The arguments are converted to a common type.) 76.5 623.67 T
+0 14 Q
+(5.9) 76.5 596.67 T
+(Comparisons) 112.5 596.67 T
+1 11 Q
+0.26 (Contrary to C, all comparison operations in Python have the same priority, which is lower than that) 76.5 571.67 P
+0.47 (of any arithmetic, shifting or bitwise operation. Also contrary to C, expressions like) 76.5 558.67 P
+2 F
+1.13 (a < b < c) 453.56 558.67 P
+1 F
+(have the interpretation that is conventional in mathematics:) 76.5 545.67 T
+2 10 Q
+(comparison:     or_expr \050comp_operator or_expr\051*) 76.5 527.33 T
+-1.8 (comp_operator:  "<"|">"|"=="|">="|"<="|"<>"|"!="|"is" ["not"]|["not"] "in") 76.5 515.33 P
+1 11 Q
+(Comparisons yield integer values: 1 for true, 0 for false.) 76.5 490.67 T
+-0.2 (Comparisons can be chained arbitrarily, e.g.) 76.5 465.67 P
+2 F
+-0.49 (x < y <= z) 272.31 465.67 P
+1 F
+-0.2 ( is equivalent to) 336.35 465.67 P
+2 F
+-0.49 (x < y and y <= z,) 408.25 465.67 P
+1 F
+-0.14 (except that) 76.5 452.67 P
+2 F
+-0.35 (y) 126.92 452.67 P
+1 F
+-0.14 ( is evaluated only once \050but in both cases) 133.52 452.67 P
+2 F
+-0.35 (z) 315.83 452.67 P
+1 F
+-0.14 ( is not evaluated at all when) 322.43 452.67 P
+2 F
+-0.35 (x < y) 446.98 452.67 P
+1 F
+-0.14 ( is found) 479.29 452.67 P
+(to be false\051.) 76.5 439.67 T
+-0.31 (Formally, if) 76.5 414.67 P
+3 F
+-0.31 (a) 131.18 414.67 P
+1 F
+-0.31 (,) 136.68 414.67 P
+3 F
+-0.31 (b) 141.87 414.67 P
+1 F
+-0.31 (,) 147.37 414.67 P
+3 F
+-0.31 (c) 152.56 414.67 P
+1 F
+-0.31 (, ...,) 157.44 414.67 P
+3 F
+-0.31 (y) 176.06 414.67 P
+1 F
+-0.31 (,) 180.95 414.67 P
+3 F
+-0.31 (z) 186.13 414.67 P
+1 F
+-0.31 ( are expressions and) 190.41 414.67 P
+3 F
+-0.31 (opa) 280.8 414.67 P
+1 F
+-0.31 (,) 297.3 414.67 P
+3 F
+-0.31 (opb) 302.49 414.67 P
+1 F
+-0.31 (, ...,) 318.99 414.67 P
+3 F
+-0.31 (opy) 337.61 414.67 P
+1 F
+-0.31 ( are comparison operators, then) 353.5 414.67 P
+3 F
+-0.31 (a opa) 493.06 414.67 P
+0.05 (b opb c) 76.5 401.67 P
+1 F
+0.05 ( ...) 108.98 401.67 P
+3 F
+0.05 (y opy z) 122.82 401.67 P
+1 F
+0.05 ( is equivalent to) 153.47 401.67 P
+3 F
+0.05 (a opa b) 226.38 401.67 P
+2 F
+0.12 (and) 262.27 401.67 P
+3 F
+0.05 (b opb c) 288.79 401.67 P
+2 F
+0.12 (and) 324.06 401.67 P
+1 F
+0.05 ( ...) 343.86 401.67 P
+3 F
+0.05 (y opy z) 360.51 401.67 P
+1 F
+0.05 (, except that each expression) 391.15 401.67 P
+(is evaluated at most once.) 76.5 388.67 T
+0.18 (Note that) 76.5 363.67 P
+3 F
+0.18 (a opa b opb c) 120.24 363.67 P
+1 F
+0.18 ( doesn\325t imply any kind of comparison between) 180.84 363.67 P
+3 F
+0.18 (a) 394.9 363.67 P
+1 F
+0.18 ( and) 400.4 363.67 P
+3 F
+0.18 (c) 422.14 363.67 P
+1 F
+0.18 (, so that e.g.) 427.02 363.67 P
+2 F
+0.43 (x < y) 483.65 363.67 P
+(> z) 76.5 350.67 T
+1 F
+( is perfectly legal \050though perhaps not pretty\051.) 96.3 350.67 T
+-0.27 (The forms) 76.5 325.67 P
+2 F
+-0.66 (<>) 124.22 325.67 P
+1 F
+-0.27 ( and) 137.42 325.67 P
+2 F
+-0.66 (!=) 158.25 325.67 P
+1 F
+-0.27 ( are equivalent; for consistency with C,) 171.45 325.67 P
+2 F
+-0.66 (!=) 344.89 325.67 P
+1 F
+-0.27 ( is preferred; where) 358.1 325.67 P
+2 F
+-0.66 (!=) 445.57 325.67 P
+1 F
+-0.27 ( is mentioned) 458.77 325.67 P
+(below) 76.5 312.67 T
+2 F
+(<>) 106.13 312.67 T
+1 F
+( is also implied.) 119.33 312.67 T
+-0.01 (The operators) 76.5 287.67 P
+2 F
+-0.02 ("<", ">", "==", ">=", "<=") 140.02 287.67 P
+1 F
+-0.01 (, and) 311.54 287.67 P
+2 F
+-0.02 ("!=") 335.65 287.67 P
+1 F
+-0.01 ( compare the values of two objects.) 362.05 287.67 P
+0.25 (The objects needn\325t have the same type. If both are numbers, they are converted to a common type.) 76.5 274.67 P
+-0.03 (Otherwise, objects of different types) 76.5 261.67 P
+3 F
+-0.03 (always) 239.46 261.67 P
+1 F
+-0.03 ( compare unequal, and are ordered consistently but arbi-) 270.02 261.67 P
+0.41 0.05 (trarily. \050This unusual definition of comparison is done to simplify the definition of operations like) 76.5 248.67 B
+(sorting and the) 76.5 235.67 T
+2 F
+(in) 144.63 235.67 T
+1 F
+( and) 157.83 235.67 T
+2 F
+(not) 179.22 235.67 T
+(in) 201.77 235.67 T
+1 F
+( operators.\051) 214.97 235.67 T
+(Comparison of objects of the same type depends on the type:) 76.5 210.67 T
+(\245) 76.5 191.67 T
+(Numbers are compared arithmetically.) 90.9 191.67 T
+(\245) 76.5 172.67 T
+0.77 (Strings are compared lexicographically using the numeric equivalents \050the result of the built-in) 90.9 172.67 P
+(function) 90.9 159.67 T
+2 F
+(ord) 130.31 159.67 T
+1 F
+(\051 of their characters.) 150.11 159.67 T
+(\245) 76.5 140.67 T
+(Tuples and lists are compared lexicographically using comparison of corresponding items.) 90.9 140.67 T
+(\245) 76.5 121.67 T
+-0.38 (Mappings \050dictionaries\051 are compared through lexicographic comparison of their sorted \050key, val-) 90.9 121.67 P
+(ue\051 lists.) 90.9 108.67 T
+1 8.8 Q
+(1) 128.18 113.07 T
+1 11 Q
+(\245) 76.5 89.67 T
+-0.13 (Most other types compare unequal unless they are the same object; the choice whether one object) 90.9 89.67 P
+-0.3 (is considered smaller or larger than another one is made arbitrarily but consistently within one ex-) 90.9 76.67 P
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "34" 40
+%%Page: "35" 41
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(35) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Expressions) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(ecution of a program.) 113.4 712.67 T
+0.05 (The operators) 99 687.67 P
+2 F
+0.12 (in) 162.64 687.67 P
+1 F
+0.05 ( and) 175.84 687.67 P
+2 F
+0.12 (not in) 197.33 687.67 P
+1 F
+0.05 ( test for sequence membership: if) 237.05 687.67 P
+3 F
+0.05 (y) 386.44 687.67 P
+1 F
+0.05 ( is a sequence,) 391.33 687.67 P
+3 F
+0.05 (x) 457.82 687.67 P
+1 F
+0.05 ( in) 462.7 687.67 P
+3 F
+0.05 (y) 476.86 687.67 P
+1 F
+0.05 ( is true if and) 481.75 687.67 P
+-0.34 (only if there exists an index) 99 674.67 P
+3 F
+-0.34 (i) 221.59 674.67 P
+1 F
+-0.34 ( such that) 224.64 674.67 P
+3 F
+-0.34 (x) 268.52 674.67 P
+1 F
+-0.34 ( =) 273.41 674.67 P
+3 F
+-0.34 (y) 284.42 674.67 P
+1 F
+-0.34 ([) 289.3 674.67 P
+3 F
+-0.34 (i) 292.97 674.67 P
+1 F
+-0.34 (].) 296.03 674.67 P
+3 F
+-0.34 (x) 304.84 674.67 P
+1 F
+-0.34 ( not in) 309.73 674.67 P
+3 F
+-0.34 (y) 339.56 674.67 P
+1 F
+-0.34 ( yields the inverse truth value. The exception) 344.44 674.67 P
+2 F
+0.6 (TypeError) 99 661.67 P
+1 F
+0.25 ( is raised when) 158.4 661.67 P
+3 F
+0.25 (y) 227.84 661.67 P
+1 F
+0.25 ( is not a sequence, or when) 232.72 661.67 P
+3 F
+0.25 (y) 356.06 661.67 P
+1 F
+0.25 ( is a string and) 360.94 661.67 P
+3 F
+0.25 (x) 429.11 661.67 P
+1 F
+0.25 ( is not a string of length) 433.99 661.67 P
+(one.) 99 648.67 T
+1 8.8 Q
+(1) 117.63 653.07 T
+1 11 Q
+-0.47 (The operators) 99 623.67 P
+2 F
+-1.14 (is) 161.59 623.67 P
+1 F
+-0.47 ( and) 174.79 623.67 P
+2 F
+-1.14 (is not) 195.22 623.67 P
+1 F
+-0.47 ( test for object identity:) 233.68 623.67 P
+3 F
+-0.47 (x) 336.72 623.67 P
+2 F
+-1.14 (is) 343.88 623.67 P
+3 F
+-0.47 (y) 359.36 623.67 P
+1 F
+-0.47 ( is true if and only if) 364.24 623.67 P
+3 F
+-0.47 (x) 453.49 623.67 P
+1 F
+-0.47 ( and) 458.38 623.67 P
+3 F
+-0.47 (y) 478.81 623.67 P
+1 F
+-0.47 ( are the same) 483.7 623.67 P
+(object.) 99 610.67 T
+3 F
+(x) 131.38 610.67 T
+2 F
+(is not) 139.02 610.67 T
+3 F
+(y) 181.37 610.67 T
+1 F
+( yields the inverse truth value.) 186.25 610.67 T
+0 14 Q
+(5.10) 99 583.67 T
+(Boolean operations) 135 583.67 T
+1 11 Q
+(Boolean operations have the lowest priority of all Python operations:) 99 558.67 T
+2 10 Q
+(expression:      or_test | lambda_form) 99 540.33 T
+(or_test:        and_test | or_test "or" and_test) 99 528.33 T
+(and_test:       not_test | and_test "and" not_test) 99 516.33 T
+(not_test:       comparison | "not" not_test) 99 504.33 T
+(lambda_form:) 99 492.33 T
+("lambda" [parameter_list]: expression) 171 492.33 T
+1 11 Q
+-0.23 (In the context of Boolean operations, and also when expressions are used by control flow statements,) 99 467.67 P
+0.41 0.17 (the following values are interpreted as false:) 99 454.67 B
+2 F
+0.99 0.17 (None) 307.52 454.67 B
+1 F
+0.41 0.17 (, numeric zero of all types, empty sequences) 334.6 454.67 B
+-0.32 (\050strings, tuples and lists\051, and empty mappings \050dictionaries\051. All other values are interpreted as true.) 99 441.67 P
+(The operator) 99 416.67 T
+2 F
+(not) 158.26 416.67 T
+1 F
+( yields 1 if its argument is false, 0 otherwise.) 178.06 416.67 T
+0.25 (The expression) 99 391.67 P
+3 F
+0.25 (x) 169.16 391.67 P
+2 F
+0.61 (and) 177.05 391.67 P
+3 F
+0.25 (y) 199.85 391.67 P
+1 F
+0.25 ( first evaluates) 204.73 391.67 P
+3 F
+0.25 (x) 272.4 391.67 P
+1 F
+0.25 (; if) 277.28 391.67 P
+3 F
+0.25 (x) 293.07 391.67 P
+1 F
+0.25 ( is false, its value is returned; otherwise,) 297.95 391.67 P
+3 F
+0.25 (y) 479.62 391.67 P
+1 F
+0.25 ( is evaluated) 484.5 391.67 P
+(and the resulting value is returned.) 99 378.67 T
+-0.18 (The expression) 99 353.67 P
+3 F
+-0.18 (x) 168.3 353.67 P
+2 F
+-0.43 (or) 175.75 353.67 P
+3 F
+-0.18 (y) 191.52 353.67 P
+1 F
+-0.18 ( first evaluates) 196.41 353.67 P
+3 F
+-0.18 (x) 262.78 353.67 P
+1 F
+-0.18 (; if) 267.66 353.67 P
+3 F
+-0.18 (x) 282.58 353.67 P
+1 F
+-0.18 ( is true, its value is returned; otherwise,) 287.47 353.67 P
+3 F
+-0.18 (y) 462.02 353.67 P
+1 F
+-0.18 ( is evaluated and) 466.91 353.67 P
+(the resulting value is returned.) 99 340.67 T
+0.04 (\050Note that neither) 99 315.67 P
+2 F
+0.09 (and) 179.46 315.67 P
+1 F
+0.04 ( nor) 199.26 315.67 P
+2 F
+0.09 (or) 219.5 315.67 P
+1 F
+0.04 ( restrict the value and type they return to 0 and 1, but rather return the) 232.7 315.67 P
+-0.34 (last evaluated argument. This is sometimes useful, e.g. if) 99 302.67 P
+2 F
+-0.82 (s) 348.61 302.67 P
+1 F
+-0.34 ( is a string that should be replaced by a de-) 355.21 302.67 P
+-0.08 (fault value if it is empty, the expression) 99 289.67 P
+2 F
+-0.19 (s or \325foo\325) 275.27 289.67 P
+1 F
+-0.08 ( yields the desired value. Because) 340.89 289.67 P
+2 F
+-0.19 (not) 491.64 289.67 P
+1 F
+-0.08 ( has to) 511.44 289.67 P
+0.36 (invent a value anyway, it does not bother to return a value of the same type as its argument, so e.g.) 99 276.67 P
+2 F
+(not \325foo\325) 99 263.67 T
+1 F
+( yields) 158.4 263.67 T
+2 F
+(0) 190.18 263.67 T
+1 F
+(, not) 196.78 263.67 T
+2 F
+(\325\325) 219.09 263.67 T
+1 F
+(.\051) 232.29 263.67 T
+0.41 0.12 (Lambda forms \050lambda expressions\051 have the same syntactic position as expressions. They are a) 99 238.67 B
+0.41 0.03 (shorthand to create anonymous functions; the expression) 99 225.67 B
+2 F
+0.99 0.03 (lambda) 356.08 225.67 B
+1 F
+0.41 0.03 ( arguments) 395.84 225.67 B
+2 F
+0.99 0.03 (:) 445.1 225.67 B
+1 F
+0.41 0.03 ( expression yields a) 451.73 225.67 B
+(function object that behaves virtually identical to one defined with) 99 212.67 T
+2 10 Q
+(def name \050arguments\051:) 99 194.33 T
+(    return expression) 99 182.33 T
+0 0 0 1 0 0 0 K
+99 128 540 143 C
+0 0 0 1 0 0 0 K
+108 141 252 141 2 L
+0.5 H
+2 Z
+0 X
+0 0 0 1 0 0 0 K
+N
+0 0 0 1 0 0 0 K
+0 0 612 792 C
+0 0 0 1 0 0 0 K
+1 11 Q
+0 X
+0 0 0 1 0 0 0 K
+(1.) 108 120.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.22 (This is expensive since it requires sorting the keys first, but about the only sensible defini-) 121.5 120.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.7 (tion. An earlier version of Python compared dictionaries by identity only, but this caused) 121.46 107.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.41 (surprises because people expected to be able to test a dictionary for emptiness by comparing) 121.46 94.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(it to) 121.46 81.67 T
+2 F
+({}) 141.64 81.67 T
+1 F
+(.) 154.84 81.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(1.) 108 68.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The latter restriction is sometimes a nuisance.) 121.5 68.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "35" 41
+%%Page: "36" 42
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(36) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.41 0 (See \322Function definitions\323 on page) 76.5 712.67 B
+0.41 0 (48 for the syntax of parameter lists. Note that functions created) 235.56 712.67 B
+(with lambda forms cannot contain statements.) 76.5 699.67 T
+0 14 Q
+(5.11) 76.5 672.67 T
+(Expression lists) 112.5 672.67 T
+2 10 Q
+(expression_list:      expression \050"," expression\051* [","]) 76.5 648.33 T
+1 11 Q
+-0.26 (An expression list containing at least one comma yields a tuple. The length of the tuple is the number) 76.5 623.67 P
+(of expressions in the list. The expressions are evaluated from left to right.) 76.5 610.67 T
+-0.04 (The trailing comma is required only to create a single tuple \050a.k.a. a) 76.5 585.67 P
+3 F
+-0.04 (single) 376.57 585.67 P
+1 F
+-0.04 (\051; it is optional in all other) 402.85 585.67 P
+-0.28 (cases. A single expression without a trailing comma doesn\325t create a tuple, but rather yields the value) 76.5 572.67 P
+(of that expression. \050To create an empty tuple, use an empty pair of parentheses:) 76.5 559.67 T
+2 F
+(\050\051) 428.42 559.67 T
+1 F
+(.\051) 441.62 559.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "36" 42
+%%Page: "37" 43
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(37) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Expressions) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(5.12) 99 710.67 T
+(Summary) 135 710.67 T
+1 11 Q
+0.37 (The following table summarizes the operator precedences in Python, from lowest precedence \050least) 99 685.67 P
+-0.23 (binding\051 to highest precedence \050most binding\051. Operators in the same box have the same precedence.) 99 672.67 P
+0.64 (Unless the syntax is explicitly given, operators are binary. Operators in the same box group left to) 99 659.67 P
+(right \050except for comparisons, which chain from left to right \321 see above\051.) 99 646.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 12 Q
+(T) 208.14 623 T
+(able 4: Operator Pr) 215.04 623 T
+(ecedence) 315.8 623 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 11 Q
+(or) 185.77 599.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Boolean OR) 350.65 599.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(and) 182.48 578.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Boolean AND) 346.38 578.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(not) 175.88 557.67 T
+6 F
+(x) 202.27 557.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Boolean NO) 347.21 557.67 T
+(T) 402.07 557.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(in, not in) 159.38 536.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(is, is not) 159.38 523.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(<, <=, >, >=, <>, !=, =) 116.47 510.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Membership tests) 339.04 536.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Identity tests) 349.74 523.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Comparisons) 348.97 510.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(|) 189.07 489.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Bitwise OR) 352.18 489.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(^) 189.07 468.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Bitwise XOR) 348.21 468.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(&) 189.07 447.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Bitwise AND) 347.9 447.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(<<, >>) 172.57 426.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Shifts) 365.16 426.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(+, -) 179.18 405.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Addition and subtraction) 323.31 405.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(*, /, %) 169.27 384.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Multiplication, di) 301.14 384.67 T
+(vision, remainder) 377.87 384.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+3 F
+(+x, -x) 179.2 363.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(~x) 186.96 350.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(Positi) 339.44 363.67 T
+(v) 364.23 363.67 T
+(e, ne) 369.57 363.67 T
+(g) 390.17 363.67 T
+(ati) 395.62 363.67 T
+(v) 406.34 363.67 T
+(e) 411.68 363.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Bitwise not) 352.79 350.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+3 F
+(x.attrib) 169.72 329.67 T
+(ute) 201.59 329.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(x) 174.47 316.67 T
+1 F
+([) 179.35 316.67 T
+3 F
+(inde) 183.01 316.67 T
+(x) 201.74 316.67 T
+1 F
+(]) 206.62 316.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+3 F
+(x) 160.83 303.67 T
+1 F
+([) 165.72 303.67 T
+3 F
+(inde) 169.38 303.67 T
+(x:inde) 188.1 303.67 T
+(x) 215.37 303.67 T
+1 F
+(]) 220.25 303.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+3 F
+(f) 157.29 290.67 T
+1 F
+(\050) 160.35 290.67 T
+3 F
+(ar) 164.01 290.67 T
+(guments) 173.38 290.67 T
+1 F
+(, ...\051) 210.05 290.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Attrib) 336.42 329.67 T
+(ute reference) 362.48 329.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Subscription) 350.19 316.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Slicing) 362.41 303.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Function call) 349.12 290.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\050) 155.11 269.67 T
+3 F
+(e) 158.78 269.67 T
+(xpr) 163.44 269.67 T
+(essions) 177.7 269.67 T
+1 F
+( . . .\051) 209.47 269.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+([) 155.11 256.67 T
+3 F
+(e) 158.78 256.67 T
+(xpr) 163.44 256.67 T
+(essions) 177.7 256.67 T
+1 F
+( . . .]) 209.47 256.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+({) 154.78 243.67 T
+3 F
+(k) 160.06 243.67 T
+(e) 164.84 243.67 T
+(y:datum) 169.39 243.67 T
+1 F
+(, . . .}) 205.44 243.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(`) 165.5 230.67 T
+3 F
+(e) 169.16 230.67 T
+(xpr) 173.83 230.67 T
+(ession) 188.09 230.67 T
+1 F
+(`) 215.59 230.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Binding or tuple display) 324.68 269.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(List display) 352.18 256.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Dictionary display) 337.21 243.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(String con) 339.35 230.67 T
+(v) 384.43 230.67 T
+(ersion) 389.77 230.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+99 612.75 99 223.25 2 L
+V
+0.5 H
+0 Z
+N
+285.75 613.25 285.75 222.75 2 L
+V
+N
+470.25 612.75 470.25 223.25 2 L
+V
+N
+98.75 613 470.5 613 2 L
+V
+N
+98.75 592 470.5 592 2 L
+V
+N
+98.75 571 470.5 571 2 L
+V
+N
+98.75 550 470.5 550 2 L
+V
+N
+98.75 503 470.5 503 2 L
+V
+N
+98.75 482 470.5 482 2 L
+V
+N
+98.75 461 470.5 461 2 L
+V
+N
+98.75 440 470.5 440 2 L
+V
+N
+98.75 419 470.5 419 2 L
+V
+N
+98.75 398 470.5 398 2 L
+V
+N
+98.75 377 470.5 377 2 L
+V
+N
+98.75 343 470.5 343 2 L
+V
+N
+98.75 283 470.5 283 2 L
+V
+N
+98.75 223 470.5 223 2 L
+V
+N
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "37" 43
+%%Page: "38" 44
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(38) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "38" 44
+%%Page: "39" 45
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(39) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Simple statements) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 16 Q
+(C) 99 709.33 T
+0 12.8 Q
+(HAPTER) 110.55 709.33 T
+0 16 Q
+(6:) 167.62 709.33 T
+(S) 198 709.33 T
+0 12.8 Q
+(IMPLE) 208.67 709.33 T
+(STATEMENTS) 252.24 709.33 T
+1 11 Q
+-0.43 (Simple statements are comprised within a single logical line. Several simple statements may occur on) 99 672.67 P
+(a single line separated by semicolons. The syntax for simple statements is:) 99 659.67 T
+2 10 Q
+(simple_stmt:    expression_stmt) 99 641.33 T
+(              | assignment_stmt) 99 629.33 T
+(              | pass_stmt) 99 617.33 T
+(              | del_stmt) 99 605.33 T
+(              | print_stmt) 99 593.33 T
+(              | return_stmt) 99 581.33 T
+(              | raise_stmt) 99 569.33 T
+(              | break_stmt) 99 557.33 T
+(              | continue_stmt) 99 545.33 T
+(              | import_stmt) 99 533.33 T
+(              | global_stmt) 99 521.33 T
+(              | exec_stmt) 99 509.33 T
+0 14 Q
+(6.1) 99 482.67 T
+(Expression statements) 135 482.67 T
+1 11 Q
+0.58 (Expression statements are used \050mostly interactively\051 to compute and write a value, or \050usually\051 to) 99 457.67 P
+-0.01 (call a procedure \050a function that returns no meaningful result; in Python, procedures return the value) 99 444.67 P
+2 F
+0.9 (None) 99 431.67 P
+1 F
+0.38 (\051. Other uses of expression statements are allowed and occasionally useful. The syntax for an) 125.4 431.67 P
+(expression statement is:) 99 418.67 T
+2 10 Q
+(expression_stmt: expression_list) 99 400.33 T
+1 11 Q
+-0.16 (An expression statement evaluates the expression list \050which may be a single expression\051. In interac-) 99 375.67 P
+-0.35 (tive mode, if the value is not) 99 362.67 P
+2 F
+-0.84 (None) 224.89 362.67 P
+1 F
+-0.35 (, it is converted to a string using the built-in) 251.29 362.67 P
+2 F
+-0.84 (repr\050\051) 443.05 362.67 P
+1 F
+-0.35 ( function and) 482.65 362.67 P
+0.28 (the resulting string is written to standard output \050see \322The print statement\323 on page) 99 349.67 P
+0.28 (41\051 on a line by) 469.84 349.67 P
+-0.24 (itself. \050Expression statements yielding) 99 336.67 P
+2 F
+-0.58 (None) 268.83 336.67 P
+1 F
+-0.24 ( are not written, so that procedure calls do not cause any) 295.23 336.67 P
+(output.\051) 99 323.67 T
+0 14 Q
+(6.2) 99 296.67 T
+(Assignment statements) 135 296.67 T
+1 11 Q
+-0.09 (Assignment statements are used to \050re\051bind names to values and to modify attributes or items of mu-) 99 271.67 P
+(table objects:) 99 258.67 T
+2 10 Q
+(assignment_stmt: \050target_list "="\051+ expression_list) 99 240.33 T
+(target_list:     target \050"," target\051* [","]) 99 228.33 T
+(target:          identifier | "\050" target_list "\051" | "[" target_list "]") 99 216.33 T
+(               | attributeref | subscription | slicing) 99 204.33 T
+1 11 Q
+(\050See \322Primaries\323 on page) 99 179.67 T
+(29 for the syntax definitions for the last three symbols.\051) 213.25 179.67 T
+-0.14 (An assignment statement evaluates the expression list \050remember that this can be a single expression) 99 154.67 P
+0.31 (or a comma-separated list, the latter yielding a tuple\051 and assigns the single resulting object to each) 99 141.67 P
+(of the target lists, from left to right.) 99 128.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "39" 45
+%%Page: "40" 46
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(40) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.07 (Assignment is defined recursively depending on the form of the target \050list\051. When a target is part of a mu-) 72 712.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.18 (table object \050an attribute reference, subscription or slicing\051, the mutable object must ultimately perform the) 72 699.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.27 (assignment and decide about its validity, and may raise an exception if the assignment is unacceptable. The) 72 686.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.27 (rules observed by various types and the exceptions raised are given with the definition of the object types) 72 673.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\050See \322The standard type hierarchy\323 on page) 72 660.67 T
+(12.\051) 267.18 660.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Assignment of an object to a target list is recursively defined as follows.) 72 635.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 616.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(If the target list is a single target: the object is assigned to that target.) 86.4 616.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 597.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.14 (If the target list is a comma-separated list of targets: the object must be a tuple with the same number of) 86.4 597.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.62 (items as there are targets in the target list, and the items are assigned, from left to right, to the correspond-) 86.4 584.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(ing targets.) 86.4 571.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Assignment of an object to a single target is recursively defined as follows.) 72 546.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 527.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(If the target is an identifier \050name\051:) 86.4 527.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 100.8 508.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.19 (If the name does not occur in a) 115.2 508.67 P
+2 F
+0.44 (global) 255.37 508.67 P
+1 F
+0.19 ( statement in the current code block: the name is bound) 294.96 508.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(to the object in the current local name space.) 115.2 495.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 100.8 476.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Otherwise: the name is bound to the object in the current global name space.) 115.2 476.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.58 (The name is rebound if it was already bound. This can cause the reference count for the object previously) 86.4 459.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(bound to the name to reach zero, causing the object to be deallocated and its) 86.4 446.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 427.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.16 (If the target is a target list enclosed in parentheses: the object is assigned to that target list as described) 86.4 427.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(above.) 86.4 414.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 395.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.24 (If the target is a target list enclosed in square brackets: the object must be a list with the same number of) 86.4 395.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.38 (items as the target list contains targets, and its items are assigned, from left to right, to the corresponding) 86.4 382.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(targets.) 86.4 369.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 350.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.56 (If the target is an attribute reference: The primary expression in the reference is evaluated. It should yield) 86.4 350.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.7 (an object with assignable attributes; if this is not the case,) 86.4 337.67 P
+2 F
+1.69 (TypeError) 350.19 337.67 P
+1 F
+0.7 ( is raised. That object is then) 409.59 337.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.34 (asked to assign the assigned object to the given attribute; if it cannot perform the assignment, it raises an) 86.4 324.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(exception \050usually but not necessarily) 86.4 311.67 T
+2 F
+(AttributeError) 255.35 311.67 T
+1 F
+(\051.) 347.75 311.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 292.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.31 (If the target is a subscription: The primary expression in the reference is evaluated. It should yield either) 86.4 292.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.25 (a mutable sequence \050list\051 object or a mapping \050dictionary\051 object. Next, the subscript expression is eval-) 86.4 279.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(uated.) 86.4 266.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.11 (If the primary is a mutable sequence object \050a list\051, the subscript must yield a plain integer. If it is nega-) 86.4 249.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.26 (tive, the sequence\325s length is added to it. The resulting value must be a nonnegative integer less than the) 86.4 236.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.01 (sequence\325s length, and the sequence is asked to assign the assigned object to its item with that index. If) 86.4 223.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.39 (the index is out of range,) 86.4 210.67 P
+2 F
+-0.93 (IndexError) 196.2 210.67 P
+1 F
+-0.39 ( is raised \050assignment to a subscripted sequence cannot add new) 262.2 210.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(items to a list\051.) 86.4 197.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.28 (If the primary is a mapping \050dictionary\051 object, the subscript must have a type compatible with the map-) 86.4 180.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.27 (ping\325s key type, and the mapping is then asked to create a key/datum pair which maps the subscript to) 86.4 167.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.15 (the assigned object. This can either replace an existing key/value pair with the same key value, or insert) 86.4 154.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(a new key/value pair \050if no key with the same value existed\051.) 86.4 141.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 122.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.06 (If the target is a slicing: The primary expression in the reference is evaluated. It should yield a mutable) 86.4 122.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.31 (sequence object \050e.g. a list\051. The assigned object should be a sequence object of the same type. Next, the) 86.4 109.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.04 (lower and upper bound expressions are evaluated, insofar they are present; defaults are zero and the se-) 86.4 96.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1.16 (quence\325s length. The bounds should evaluate to \050small\051 integers. If either bound is negative, the se-) 86.4 83.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "40" 46
+%%Page: "41" 47
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(41) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Simple statements) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+1.71 (quence\325s length is added to it. The resulting bounds are clipped to lie between zero and the) 113.4 712.67 P
+0.95 (sequence\325s length, inclusive. Finally, the sequence object is asked to replace the slice with the) 113.4 699.67 P
+-0.15 (items of the assigned sequence. The length of the slice may be different from the length of the as-) 113.4 686.67 P
+(signed sequence, thus changing the length of the target sequence, if the object allows it.) 113.4 673.67 T
+0.15 (\050In the current implementation, the syntax for targets is taken to be the same as for expressions, and) 99 648.67 P
+(invalid syntax is rejected during the code generation phase, causing less detailed error messages.\051) 99 635.67 T
+0.14 (WARNING: Although the definition of assignment implies that overlaps between the left-hand side) 99 610.67 P
+-0.28 (and the right-hand side are \324safe\325 \050e.g. \324\324) 99 597.67 P
+2 F
+-0.68 (a,) 274.49 597.67 P
+-0.68 (b) 290.16 597.67 P
+-0.68 (=) 299.23 597.67 P
+-0.68 (b,) 308.3 597.67 P
+-0.68 (a) 323.96 597.67 P
+1 F
+-0.28 (\325\325 swaps two variables\051, overlaps) 330.56 597.67 P
+3 F
+-0.28 (within) 477.01 597.67 P
+1 F
+-0.28 ( the col-) 504.52 597.67 P
+-0.19 (lection of assigned-to variables are not safe! For instance, the following program prints \324\324) 99 584.67 P
+2 F
+-0.46 ([0,) 490.02 584.67 P
+-0.46 (2]) 516.42 584.67 P
+1 F
+-0.19 (\325\325:) 529.62 584.67 P
+2 10 Q
+(x = [0, 1]) 99 566.33 T
+(i = 0) 99 554.33 T
+(i, x[i] = 1, 2) 99 542.33 T
+(print x) 99 530.33 T
+0 14 Q
+(6.3) 99 503.67 T
+(The) 135 503.67 T
+2 F
+(pass) 163.78 503.67 T
+0 F
+( statement) 197.38 503.67 T
+2 10 Q
+(pass_stmt:      "pass") 99 479.33 T
+2 11 Q
+0.21 (pass) 99 454.67 P
+1 F
+0.09 ( is a null operation \321 when it is executed, nothing happens. It is useful as a placeholder when) 125.4 454.67 P
+(a statement is required syntactically, but no code needs to be executed, for example:) 99 441.67 T
+2 10 Q
+(def f\050arg\051: pass    # a function that does nothing \050yet\051) 99 423.33 T
+(class C: pass       # a class with no methods \050yet\051) 99 411.33 T
+0 14 Q
+(6.4) 99 384.67 T
+(The) 135 384.67 T
+2 F
+(del) 163.78 384.67 T
+0 F
+( statement) 188.98 384.67 T
+2 10 Q
+(del_stmt:       "del" target_list) 99 360.33 T
+1 11 Q
+0.19 (Deletion is recursively defined very similar to the way assignment is defined. Rather that spelling it) 99 335.67 P
+(out in full details, here are some hints.) 99 322.67 T
+(Deletion of a target list recursively deletes each target, from left to right.) 99 297.67 T
+0.41 0.09 (Deletion of a name removes the binding of that name \050which must exist\051 from the local or global) 99 272.67 B
+-0 (name space, depending on whether the name occurs in a) 99 259.67 P
+2 F
+-0 (global) 349.18 259.67 P
+1 F
+-0 ( statement in the same code block.) 388.78 259.67 P
+0.32 (Deletion of attribute references, subscriptions and slicings is passed to the primary object involved;) 99 234.67 P
+-0.54 (deletion of a slicing is in general equivalent to assignment of an empty slice of the right type \050but even) 99 221.67 P
+(this is determined by the sliced object\051.) 99 208.67 T
+0 14 Q
+(6.5) 99 181.67 T
+(The) 135 181.67 T
+2 F
+(print) 163.78 181.67 T
+0 F
+( statement) 205.78 181.67 T
+2 10 Q
+(print_stmt:     "print" [ expression \050"," expression\051* [","] ]) 99 157.33 T
+2 11 Q
+0.81 (print) 99 132.67 P
+1 F
+0.34 ( evaluates each expression in turn and writes the resulting object to standard output \050see be-) 132 132.67 P
+-0.02 (low\051. If an object is not a string, it is first converted to a string using the rules for string conversions.) 99 119.67 P
+0.32 (The \050resulting or original\051 string is then written. A space is written before each object is \050converted) 99 106.67 P
+0.23 (and\051 written, unless the output system believes it is positioned at the beginning of a line. This is the) 99 93.67 P
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "41" 47
+%%Page: "42" 48
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(42) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.27 (case: \0501\051 when no characters have yet been written to standard output; or \0502\051 when the last character written) 72 712.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.02 (to standard output is) 72 699.67 B
+2 F
+0.99 0.02 (\134n) 166.45 699.67 B
+1 F
+0.41 0.02 (; or \0503\051 when the last write operation on standard output was not a) 179.7 699.67 B
+2 F
+0.99 0.02 (print) 479.77 699.67 B
+1 F
+0.41 0.02 ( state-) 512.89 699.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(ment. \050In some cases it may be functional to write an empty string to standard output for this reason.\051) 72 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.36 (A) 72 661.67 P
+2 F
+0.87 ("\134n") 83.05 661.67 P
+1 F
+0.36 ( character is written at the end, unless the) 109.45 661.67 P
+2 F
+0.87 (print) 297.21 661.67 P
+1 F
+0.36 ( statement ends with a comma. This is the only) 330.21 661.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.54 (action if the statement contains just the keyword) 72 648.67 P
+2 F
+-1.3 (print) 283.36 648.67 P
+1 F
+-0.54 (. Standard output is defined as the file object named) 316.36 648.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+-0.69 (stdout) 72 635.67 P
+1 F
+-0.29 (in the built-in module) 117.5 635.67 P
+2 F
+-0.69 (sys) 214.74 635.67 P
+1 F
+-0.29 (. If no such object exists, or if it is not a writable file, a) 234.54 635.67 P
+2 F
+-0.69 (RuntimeEr-) 474 635.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.99 0 (ror) 72 622.67 B
+1 F
+0.41 0 ( exception is raised. \050The original implementation attempts to write to the system\325s original standard) 91.81 622.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(output instead, but this is not safe, and should be fixed.\051) 72 609.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(6.6) 72 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 108 582.67 T
+2 F
+(return) 136.78 582.67 T
+0 F
+( statement) 187.18 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(return_stmt:    "return" [expression_list]) 72 558.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 11 Q
+(return) 72 533.67 T
+1 F
+( may only occur syntactically nested in a function definition, not within a nested class definition.) 111.6 533.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(If an expression list is present, it is evaluated, else) 72 508.67 T
+2 F
+(None) 295.02 508.67 T
+1 F
+(is substituted.) 328.02 508.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+(return) 72 483.67 T
+1 F
+( leaves the current function call with the expression list \050or) 111.6 483.67 T
+2 F
+(None) 372.81 483.67 T
+1 F
+(\051 as return value.) 399.21 483.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.36 (When) 72 458.67 P
+2 F
+0.87 (return) 101.38 458.67 P
+1 F
+0.36 ( passes control out of a) 140.98 458.67 P
+2 F
+0.87 (try) 247.04 458.67 P
+1 F
+0.36 ( statement with a) 266.84 458.67 P
+2 F
+0.87 (finally) 345.9 458.67 P
+1 F
+0.36 ( clause, that finally clause is exe-) 392.1 458.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(cuted before really leaving the function.) 72 445.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(6.7) 72 418.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 108 418.67 T
+2 F
+(raise) 136.78 418.67 T
+0 F
+( statement) 178.78 418.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(raise_stmt:     "raise" expression ["," expression ["," expression]]) 72 394.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 11 Q
+-0.98 (raise) 72 369.67 P
+1 F
+-0.41 ( evaluates its first expression, which must yield a string, class, or instance object. If there is a second) 105 369.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.02 (expression, this is evaluated, else) 72 356.67 P
+2 F
+0.06 (None) 220.91 356.67 P
+1 F
+0.02 ( is substituted. If the first expression is a class object, then the sec-) 247.31 356.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.54 (ond expression must be an instance of that class or one of its derivatives. If the first expression is an instance) 72 343.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(object, the second expression must be) 72 330.67 T
+2 F
+(None) 240.95 330.67 T
+1 F
+(.) 267.35 330.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.45 (If the first object is a class or string, it then raises the exception identified by the first object, with the second) 72 305.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.47 (one \050or) 72 292.67 P
+2 F
+-1.12 (None) 105.28 292.67 P
+1 F
+-0.47 (\051 as its parameter. If the first object is an instance, it raises the exception identified by the class) 131.68 292.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.08 (of the object, with the instance as its parameter \050and there should be no second object, or the second object) 72 279.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(should be) 72 266.67 T
+2 F
+(None) 117.22 266.67 T
+1 F
+(\051.) 143.62 266.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.34 (If a third object is present, and it is not) 72 241.67 P
+2 F
+0.82 (None) 248.05 241.67 P
+1 F
+0.34 (, it should be a traceback object \050see  page) 274.45 241.67 P
+0.34 (17 traceback ob-) 466.01 241.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.14 (jects\051, and it is substituted instead of the current location as the place where the exception occurred. This is) 72 228.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(useful to re-raise an exception transparently in an except clause.) 72 215.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(6.8) 72 188.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 108 188.67 T
+2 F
+(break) 136.78 188.67 T
+0 F
+( statement) 178.78 188.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(break_stmt:     "break") 72 164.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 11 Q
+-0.27 (break) 72 139.67 P
+1 F
+-0.11 ( may only occur syntactically nested in a) 105 139.67 P
+2 F
+-0.27 (for) 286.17 139.67 P
+1 F
+-0.11 (or) 312.3 139.67 P
+2 F
+-0.27 (while) 324.1 139.67 P
+1 F
+-0.11 ( loop, but not nested in a function or class) 357.1 139.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(definition within that loop.) 72 126.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(It terminates the nearest enclosing loop, skipping the optional) 72 101.67 T
+2 F
+(else) 345.76 101.67 T
+1 F
+( clause if the loop has one.) 372.16 101.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(If a) 72 76.67 T
+2 F
+(for) 89.71 76.67 T
+1 F
+( loop is terminated by) 109.51 76.67 T
+2 F
+(break) 208.2 76.67 T
+1 F
+(, the loop control target keeps its current value.) 241.2 76.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "42" 48
+%%Page: "43" 49
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(43) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Simple statements) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.55 (When) 99 712.67 P
+2 F
+-1.32 (break) 127.47 712.67 P
+1 F
+-0.55 ( passes control out of a) 160.47 712.67 P
+2 F
+-1.32 (try) 261.05 712.67 P
+1 F
+-0.55 ( statement with a) 280.85 712.67 P
+2 F
+-1.32 (finally) 356.26 712.67 P
+1 F
+-0.55 ( clause, that finally clause is ex-) 402.46 712.67 P
+(ecuted before really leaving the loop.) 99 699.67 T
+0 14 Q
+(6.9) 99 672.67 T
+(The) 135 672.67 T
+2 F
+(continue) 163.78 672.67 T
+0 F
+( statement) 230.98 672.67 T
+2 10 Q
+(continue_stmt:  "continue") 99 648.33 T
+2 11 Q
+-1.3 (continue) 99 623.67 P
+1 F
+-0.54 ( may only occur syntactically nested in a) 151.8 623.67 P
+2 F
+-1.3 (for) 329.54 623.67 P
+1 F
+-0.54 ( or) 349.34 623.67 P
+2 F
+-1.3 (while) 362.92 623.67 P
+1 F
+-0.54 ( loop, but not nested in a function) 395.92 623.67 P
+0.04 (or class definition or) 99 610.67 P
+2 F
+0.1 (try) 192.65 610.67 P
+1 F
+0.04 ( statement within that loop.) 212.45 610.67 P
+1 8.8 Q
+0.03 (1) 332.7 615.07 P
+1 11 Q
+0.04 ( It continues with the next cycle of the nearest) 337.1 610.67 P
+(enclosing loop.) 99 597.67 T
+0 14 Q
+(6.10) 99 570.67 T
+(The) 135 570.67 T
+2 F
+(import) 163.78 570.67 T
+0 F
+( statement) 214.18 570.67 T
+2 10 Q
+(import_stmt:    "import" identifier \050"," identifier\051*) 99 546.33 T
+(              | "from" identifier "import" identifier \050"," identifier\051*) 99 534.33 T
+(            | "from" identifier "import" "*") 99 522.33 T
+1 11 Q
+-0.55 (Import statements are executed in two steps: \0501\051 find a module, and initialize it if necessary; \0502\051 define) 99 497.67 P
+-0.53 (a name or names in the local name space \050of the scope where the) 99 484.67 P
+2 F
+-1.26 (import) 379.39 484.67 P
+1 F
+-0.53 ( statement occurs\051. The first) 418.99 484.67 P
+-0.12 (form \050without) 99 471.67 P
+2 F
+-0.29 (from) 162.92 471.67 P
+1 F
+-0.12 (\051 repeats these steps for each identifier in the list, the) 189.32 471.67 P
+2 F
+-0.29 (from) 422.62 471.67 P
+1 F
+-0.12 ( form performs them) 449.02 471.67 P
+(once, with the first identifier specifying the module name.) 99 458.67 T
+0.38 (The system maintains a table of modules that have been initialized, indexed by module name. \050The) 99 433.67 P
+0.41 0.1 (current implementation makes this table accessible as) 99 420.67 B
+2 F
+0.99 0.1 (sys.modules) 346.17 420.67 B
+1 F
+0.41 0.1 (.\051 When a module name is) 419.93 420.67 B
+0.41 0.03 (found in this table, step \0501\051 is finished. If not, a search for a module definition is started. This first) 99 407.67 B
+-0.42 (looks for a built-in module definition, and if no built-in module if the given name is found, it searches) 99 394.67 P
+0.12 (a user-specified list of directories for a file whose name is the module name with extension) 99 381.67 P
+2 F
+0.3 (".py") 504.25 381.67 P
+1 F
+0.12 (.) 537.25 381.67 P
+0.41 0.05 (\050The current implementation uses the list of strings) 99 368.67 B
+2 F
+0.99 0.05 (sys.path) 332.42 368.67 B
+1 F
+0.41 0.05 ( as the search path; it is initialized) 385.64 368.67 B
+(from the shell environment variable) 99 355.67 T
+2 F
+($PYTHONPATH) 259.39 355.67 T
+1 F
+(, with an installation-dependent default.\051) 331.99 355.67 T
+0.12 (If a built-in module is found, its built-in initialization code is executed and step \0501\051 is finished. If no) 99 330.67 P
+-0.42 (matching file is found,) 99 317.67 P
+2 F
+-1 (ImportError) 199.69 317.67 P
+1 F
+-0.42 ( is raised. If a file is found, it is parsed, yielding an executable) 272.29 317.67 P
+0.41 0.01 (code block. If a syntax error occurs,) 99 304.67 B
+2 F
+0.99 0.01 (SyntaxError) 263.44 304.67 B
+1 F
+0.41 0.01 ( is raised. Otherwise, an empty module of the) 336.21 304.67 B
+-0.52 (given name is created and inserted in the module table, and then the code block is executed in the con-) 99 291.67 P
+(text of this module. Exceptions during this execution terminate step \0501\051.) 99 278.67 T
+(When step \0501\051 finishes without raising an exception, step \0502\051 can begin.) 99 253.67 T
+0.38 (The first form of) 99 228.67 P
+2 F
+0.9 (import) 176.87 228.67 P
+1 F
+0.38 ( statement binds the module name in the local name space to the module) 216.47 228.67 P
+-0.05 (object, and then goes on to import the next identifier, if any. The) 99 215.67 P
+2 F
+-0.12 (from) 385.56 215.67 P
+1 F
+-0.05 ( form does not bind the mod-) 411.96 215.67 P
+-0.36 (ule name: it goes through the list of identifiers, looks each one of them up in the module found in step) 99 202.67 P
+-0.11 (\0501\051, and binds the name in the local name space to the object thus found. If a name is not found,) 99 189.67 P
+2 F
+-0.25 (Im-) 520.2 189.67 P
+-0.68 (portError) 99 176.67 P
+1 F
+-0.28 ( is raised. If the list of identifiers is replaced by a star \050) 158.4 176.67 P
+2 F
+-0.68 (*) 394.86 176.67 P
+1 F
+-0.28 (\051, all names defined in the mod-) 401.46 176.67 P
+(ule are bound, except those beginning with an underscore\050) 99 163.67 T
+2 F
+(_) 355.92 163.67 T
+1 F
+(\051.) 362.52 163.67 T
+(Names bound by import statements may not occur in) 99 138.67 T
+2 F
+(global) 334.57 138.67 T
+1 F
+( statements in the same scope.) 374.17 138.67 T
+(The) 99 113.67 T
+2 F
+(from) 118.86 113.67 T
+1 F
+( form with) 145.26 113.67 T
+2 F
+(*) 194.45 113.67 T
+1 F
+( may only occur in a module scope.) 201.05 113.67 T
+0 0 0 1 0 0 0 K
+99 76 540 91 C
+0 0 0 1 0 0 0 K
+108 89 252 89 2 L
+0.5 H
+2 Z
+0 X
+0 0 0 1 0 0 0 K
+N
+0 0 0 1 0 0 0 K
+0 0 612 792 C
+0 0 0 1 0 0 0 K
+1 11 Q
+0 X
+0 0 0 1 0 0 0 K
+(1.) 108 68.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Except that it may currently occur within an) 121.5 68.67 T
+2 F
+(except) 318.25 68.67 T
+1 F
+( clause.) 357.85 68.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "43" 49
+%%Page: "44" 50
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(44) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.37 (\050The current implementation does not enforce the latter two restrictions, but programs should not abuse this) 72 712.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(freedom, as future implementations may enforce them or silently change the meaning of the program.\051) 72 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(6.11) 72 672.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 108 672.67 T
+2 F
+(global) 136.78 672.67 T
+0 F
+( statement) 187.18 672.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(global_stmt:    "global" identifier \050"," identifier\051*) 72 648.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.25 (The) 72 623.67 P
+2 F
+-0.6 (global) 91.61 623.67 P
+1 F
+-0.25 ( statement is a declaration which holds for the entire current code block. It means that the list-) 131.21 623.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.19 (ed identifiers are to be interpreted as globals. While) 72 610.67 P
+3 F
+-0.19 (using) 300.64 610.67 P
+1 F
+-0.19 ( global names is automatic if they are not defined) 324.48 610.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(in the local scope,) 72 597.67 T
+3 F
+(assigning) 154.18 597.67 T
+1 F
+( to global names would be impossible without) 196.35 597.67 T
+2 F
+(global) 401.69 597.67 T
+1 F
+(.) 441.29 597.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.28 (Names listed in a) 72 572.67 P
+2 F
+0.68 (global) 151.95 572.67 P
+1 F
+0.28 ( statement must not be used in the same code block before that) 191.55 572.67 P
+2 F
+0.68 (global) 473.54 572.67 P
+1 F
+0.28 ( state-) 513.14 572.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(ment is executed.) 72 559.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.41 (Names listed in a) 72 534.67 P
+2 F
+-0.99 (global) 149.18 534.67 P
+1 F
+-0.41 ( statement must not be defined as formal parameters or in a) 188.78 534.67 P
+2 F
+-0.99 (for) 447.19 534.67 P
+1 F
+-0.41 ( loop control tar-) 466.99 534.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(get,) 72 521.67 T
+2 F
+(class) 90.94 521.67 T
+1 F
+(definition, function definition, or) 130.54 521.67 T
+2 F
+(import) 278.43 521.67 T
+1 F
+( statement.) 318.03 521.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.37 (\050The current implementation does not enforce the latter two restrictions, but programs should not abuse this) 72 496.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(freedom, as future implementations may enforce them or silently change the meaning of the program.\051) 72 483.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.03 (Note: the) 72 458.67 P
+2 F
+-0.06 (global) 115.33 458.67 P
+1 F
+-0.03 ( is a directive to the parser. Therefore, it applies only to code parsed at the same time as) 154.93 458.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.32 (the) 72 445.67 P
+2 F
+-0.77 (global) 87.87 445.67 P
+1 F
+-0.32 (statement. In particular, a) 133.29 445.67 P
+2 F
+-0.77 (global) 246.86 445.67 P
+1 F
+-0.32 ( statement contained in an) 286.46 445.67 P
+2 F
+-0.77 (exec) 402.47 445.67 P
+1 F
+-0.32 ( statement does not affect) 428.87 445.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.12 (the code block) 72 432.67 P
+3 F
+-0.12 (containing) 138.56 432.67 P
+1 F
+-0.12 (the) 188.25 432.67 P
+2 F
+-0.28 (exec) 204.33 432.67 P
+1 F
+-0.12 ( statement, and code contained in an) 230.73 432.67 P
+2 F
+-0.28 (exec) 392.45 432.67 P
+1 F
+-0.12 (statement is unaffected by) 425.17 432.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+-0.24 (global) 72 419.67 P
+1 F
+-0.1 ( statements in the code containing the) 111.6 419.67 P
+2 F
+-0.24 (exec) 279.25 419.67 P
+1 F
+-0.1 ( statement. The same applies to the) 305.65 419.67 P
+2 F
+-0.24 (eval\050\051) 462 419.67 P
+1 F
+-0.1 (,) 501.6 419.67 P
+2 F
+-0.24 (exec-) 507 419.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(file\050\051) 72 406.67 T
+1 F
+( and) 111.6 406.67 T
+2 F
+(compile\050\051) 132.98 406.67 T
+1 F
+( functions.) 192.38 406.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(6.12) 72 379.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 108 379.67 T
+2 F
+(exec) 136.78 379.67 T
+0 F
+( statement) 170.38 379.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(exec_stmt:    "exec" expression ["in" expression ["," expression]]) 72 355.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.21 (This statement supports dynamic execution of Python code. The first expression should evaluate to either a) 72 330.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 (string, an open file object, or a code object. If it is a string, the string is parsed as a suite of Python state-) 72 317.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.22 (ments which is then executed \050unless a syntax error occurs\051. If it is an open file, the file is parsed until EOF) 72 304.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(and executed. If it is a code object, it is simply executed.) 72 291.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.14 (In all cases, if the optional parts are omitted, the code is executed in the current scope. If only the first ex-) 72 266.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.17 (pression after) 72 253.67 P
+2 F
+-0.42 (in) 133.97 253.67 P
+1 F
+-0.17 ( is specified, it should be a dictionary, which will be used for both the global and the local) 147.17 253.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.1 (variables. If two expressions are given, both must be dictionaries and they are used for the global and local) 72 240.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(variables, respectively.) 72 227.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.06 (Hints: dynamic evaluation of expressions is supported by the built-in function) 72 202.67 P
+2 F
+-0.15 (eval\050\051) 416.88 202.67 P
+1 F
+-0.06 (. The built-in func-) 456.48 202.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.15 (tions) 72 189.67 P
+2 F
+-0.36 (globals\050\051) 96 189.67 P
+1 F
+-0.15 ( and) 155.4 189.67 P
+2 F
+-0.36 (locals\050\051) 176.48 189.67 P
+1 F
+-0.15 ( return the current global and local dictionary, respectively, which may) 229.28 189.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(be useful to pass around for use by) 72 176.67 T
+2 F
+(exec) 227.8 176.67 T
+1 F
+(.) 254.2 176.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "44" 50
+%%Page: "45" 51
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(45) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Compound statements) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 16 Q
+(C) 99 709.33 T
+0 12.8 Q
+(HAPTER) 110.55 709.33 T
+0 16 Q
+(7:) 167.62 709.33 T
+(C) 198 709.33 T
+0 12.8 Q
+(OMPOUND) 209.55 709.33 T
+(STATEMENTS) 280.84 709.33 T
+1 11 Q
+0.72 (Compound statements contain \050groups of\051 other statements; they affect or control the execution of) 99 672.67 P
+0.31 (those other statements in some way. In general, compound statements span multiple lines, although) 99 659.67 P
+(in simple incarnations a whole compound statement may be contained in one line.) 99 646.67 T
+-0.48 (The) 99 627.67 P
+2 F
+-1.15 (if) 118.38 627.67 P
+1 F
+-0.48 (,) 131.58 627.67 P
+2 F
+-1.15 (while) 136.6 627.67 P
+1 F
+-0.48 ( and) 169.6 627.67 P
+2 F
+-1.15 (for) 190.02 627.67 P
+1 F
+-0.48 ( statements implement traditional control flow constructs.) 209.82 627.67 P
+2 F
+-1.15 (try) 463.12 627.67 P
+1 F
+-0.48 ( specifies ex-) 482.92 627.67 P
+-0.62 (ception handlers and/or cleanup code for a group of statements. Function and class definitions are also) 99 614.67 P
+(syntactically compound statements.) 99 601.67 T
+0.45 (Compound statements consist of one or more \324clauses\325. A clause consists of a header and a \324suite\325.) 99 582.67 P
+0.85 (The clause headers of a particular compound statement are all at the same indentation level. Each) 99 569.67 P
+0.28 (clause header begins with a uniquely identifying keyword and ends with a colon. A suite is a group) 99 556.67 P
+0.52 (of statements controlled by a clause. A suite can be one or more semicolon-separated simple state-) 99 543.67 P
+-0.15 (ments on the same line as the header, following the header\325s colon, or it can be one or more indented) 99 530.67 P
+-0.6 (statements on subsequent lines. Only the latter form of suite can contain nested compound statements;) 99 517.67 P
+0.67 (the following is illegal, mostly because it wouldn\325t be clear to which) 99 504.67 P
+2 F
+1.6 (if) 411.59 504.67 P
+1 F
+0.67 ( clause a following) 424.79 504.67 P
+2 F
+1.6 (else) 513.6 504.67 P
+1 F
+(clause would belong:) 99 491.67 T
+2 10 Q
+(if test1: if test2: print x) 99 473.33 T
+1 11 Q
+0.14 (Also note that the semicolon binds tighter than the colon in this context, so that in the following ex-) 99 448.67 P
+(ample, either all or none of the) 99 435.67 T
+2 F
+(print) 237.08 435.67 T
+1 F
+( statements are executed:) 270.08 435.67 T
+2 10 Q
+(if x < y < z: print x; print y; print z) 99 417.33 T
+1 11 Q
+(Summarizing:) 99 392.67 T
+2 10 Q
+(compound_stmt:  if_stmt | while_stmt | for_stmt) 99 374.33 T
+(              | try_stmt | funcdef | classdef) 99 362.33 T
+(suite:          stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT) 99 350.33 T
+(statement:      stmt_list NEWLINE | compound_stmt) 99 338.33 T
+(stmt_list:      simple_stmt \050";" simple_stmt\051* [";"]) 99 326.33 T
+1 11 Q
+0.11 (Note that statements always end in a) 99 301.67 P
+2 F
+0.26 (NEWLINE) 263.19 301.67 P
+1 F
+0.11 ( possibly followed by a) 309.39 301.67 P
+2 F
+0.26 (DEDENT) 415.34 301.67 P
+1 F
+0.11 (. Also note that op-) 454.94 301.67 P
+0.11 (tional continuation clauses always begin with a keyword that cannot start a statement, thus there are) 99 288.67 P
+-0.05 (no ambiguities \050the \324dangling) 99 275.67 P
+2 F
+-0.12 (else) 231.41 275.67 P
+1 F
+-0.05 (\325 problem is solved in Python by requiring nested) 257.81 275.67 P
+2 F
+-0.12 (if) 477.66 275.67 P
+1 F
+-0.05 ( statements) 490.86 275.67 P
+(to be indented\051.) 99 262.67 T
+0.37 (The formatting of the grammar rules in the following sections places each clause on a separate line) 99 237.67 P
+(for clarity.) 99 224.67 T
+0 14 Q
+(7.1) 99 197.67 T
+(The) 135 197.67 T
+2 F
+(if) 163.78 197.67 T
+0 F
+( statement) 180.58 197.67 T
+1 11 Q
+(The) 99 172.67 T
+2 F
+(if) 118.86 172.67 T
+1 F
+( statement is used for conditional execution:) 132.05 172.67 T
+2 10 Q
+(if_stmt:        "if" expression ":" suite) 99 154.33 T
+(               \050"elif" expression ":" suite\051*) 99 142.33 T
+(               ["else" ":" suite]) 99 130.33 T
+1 11 Q
+0.26 (It selects exactly one of the suites by evaluating the expressions one by one until one is found to be) 99 105.67 P
+-0.1 (true \050see section \322Boolean operations\323 on page) 99 92.67 P
+-0.1 (35 for the definition of true and false\051; then that suite) 307.63 92.67 P
+0.41 0.05 (is executed \050and no other part of the) 99 79.67 B
+2 F
+0.99 0.05 (if) 265.64 79.67 B
+1 F
+0.41 0.05 ( statement is executed or evaluated\051. If all expressions are) 278.95 79.67 B
+(false, the suite of the) 99 66.67 T
+2 F
+(else) 193.09 66.67 T
+1 F
+( clause, if present, is executed.) 219.49 66.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "45" 51
+%%Page: "46" 52
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(46) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(7.2) 72 710.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 108 710.67 T
+7 F
+(while) 136.78 710.67 T
+0 F
+( statement) 178.78 710.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(The) 72 685.67 T
+2 F
+(while) 91.86 685.67 T
+1 F
+( statement is used for repeated execution as long as an expression is true:) 124.86 685.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(while_stmt:     "while" expression ":" suite) 72 667.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(               ["else" ":" suite]) 72 655.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.37 (This repeatedly tests the expression and, if it is true, executes the first suite; if the expression is false \050which) 72 630.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.53 (may be the first time it is tested\051 the suite of the) 72 617.67 P
+2 F
+-1.28 (else) 278.27 617.67 P
+1 F
+-0.53 ( clause, if present, is executed and the loop terminates.) 304.67 617.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.07 (A) 72 592.67 B
+2 F
+0.99 0.07 (break) 83.25 592.67 B
+1 F
+0.41 0.07 ( statement executed in the first suite terminates the loop without executing the) 116.62 592.67 B
+2 F
+0.99 0.07 (else) 474.06 592.67 B
+1 F
+0.41 0.07 ( clause\325s) 500.75 592.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.02 (suite. A) 72 579.67 P
+2 F
+-0.04 (continue) 108.94 579.67 P
+1 F
+-0.02 ( statement executed in the first suite skips the rest of the suite and goes back to testing) 161.74 579.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(the expression.) 72 566.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(7.3) 72 539.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The) 108 539.67 T
+7 F
+(for) 136.78 539.67 T
+0 F
+( statement) 161.98 539.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(The) 72 514.67 T
+2 F
+(for) 91.86 514.67 T
+1 F
+( statement is used to iterate over the elements of a sequence \050string, tuple or list\051:) 111.65 514.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(for_stmt:       "for" target_list "in" expression_list ":" suite) 72 496.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(               ["else" ":" suite]) 72 484.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.29 (The expression list is evaluated once; it should yield a sequence. The suite is then executed once for each) 72 459.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.06 (item in the sequence, in the order of ascending indices. Each item in turn is assigned to the target list using) 72 446.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.16 (the standard rules for assignments, and then the suite is executed. When the items are exhausted \050which is) 72 433.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.42 (immediately when the sequence is empty\051, the suite in the) 72 420.67 P
+2 F
+-1 (else) 325.39 420.67 P
+1 F
+-0.42 ( clause, if present, is executed, and the loop) 351.79 420.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(terminates.) 72 407.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.07 (A) 72 382.67 B
+2 F
+0.99 0.07 (break) 83.25 382.67 B
+1 F
+0.41 0.07 ( statement executed in the first suite terminates the loop without executing the) 116.62 382.67 B
+2 F
+0.99 0.07 (else) 474.06 382.67 B
+1 F
+0.41 0.07 ( clause\325s) 500.75 382.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.34 (suite. A) 72 369.67 P
+2 F
+0.81 (continue) 109.65 369.67 P
+1 F
+0.34 ( statement executed in the first suite skips the rest of the suite and continues with the) 162.45 369.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(next item, or with the) 72 356.67 T
+2 F
+(else) 169.16 356.67 T
+1 F
+(clause if there was no next item.) 202.16 356.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(The suite may assign to the variable\050s\051 in the target list; this does not affect the next item assigned to it.) 72 331.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.39 (The target list is not deleted when the loop is finished, but if the sequence is empty, it will not have been) 72 306.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.23 (assigned to at all by the loop. Hint: the built-in function) 72 293.67 P
+2 F
+0.54 (range\050\051) 321.99 293.67 P
+1 F
+0.23 ( returns a sequence of integers suitable) 368.19 293.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.07 (to emulate the effect of Pascal\325s) 72 280.67 P
+2 F
+-0.17 (for i := a to b do) 215.15 280.67 P
+1 F
+-0.07 (; e.g.) 332.93 280.67 P
+2 F
+-0.17 (range\0503\051) 357.23 280.67 P
+1 F
+-0.07 ( returns the list) 410.03 280.67 P
+2 F
+-0.17 ([0, 1, 2]) 478.19 280.67 P
+1 F
+-0.07 (.) 537.25 280.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+4 F
+-0.28 (Warning:) 72 255.67 P
+1 F
+-0.28 ( There is a subtlety when the sequence is being modified by the loop \050this can only occur for mu-) 117.84 255.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.2 (table sequences, i.e. lists\051. An internal counter is used to keep track of which item is used next, and this is) 72 242.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.05 (incremented on each iteration. When this counter has reached the length of the sequence the loop termi-) 72 229.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.08 (nates. This means that if the suite deletes the current \050or a previous\051 item from the sequence, the next item) 72 216.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.08 (will be skipped \050since it gets the index of the current item which has already been treated\051. Likewise, if the) 72 203.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.06 (suite inserts an item in the sequence before the current item, the current item will be treated again the next) 72 190.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.17 (time through the loop. This can lead to nasty bugs that can be avoided by making a temporary copy using a) 72 177.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(slice of the whole sequence, e.g.) 72 164.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(for x in a[:]:) 72 146.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(    if x < 0: a.remove\050x\051) 72 134.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "46" 52
+%%Page: "47" 53
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(47) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Compound statements) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(7.4) 99 710.67 T
+(The) 135 710.67 T
+7 F
+(try) 163.78 710.67 T
+0 F
+( statement) 188.98 710.67 T
+1 11 Q
+(The) 99 685.67 T
+2 F
+(try) 118.86 685.67 T
+1 F
+( statement specifies exception handlers and/or cleanup code for a group of statements:) 138.65 685.67 T
+2 10 Q
+(try_stmt:       try_exc_stmt | try_fin_stmt) 99 667.33 T
+(try_exc_stmt:   "try" ":" suite) 99 655.33 T
+(               \050"except" [expression ["," target]] ":" suite\051+) 99 643.33 T
+(               ["else" ":" suite]) 99 631.33 T
+(try_fin_stmt:   "try" ":" suite) 99 619.33 T
+(               "finally" ":" suite) 99 607.33 T
+1 11 Q
+-0.16 (There are two forms of) 99 582.67 P
+2 F
+-0.38 (try) 202.36 582.67 P
+1 F
+-0.16 ( statement:) 222.16 582.67 P
+2 F
+-0.38 (try...except) 272.56 582.67 P
+1 F
+-0.16 ( and) 351.76 582.67 P
+2 F
+-0.38 (try...finally) 372.82 582.67 P
+1 F
+-0.16 (. These forms can-) 458.62 582.67 P
+(not be mixed \050but they can be nested in each other\051.) 99 569.67 T
+0.25 (The) 99 544.67 P
+2 F
+0.6 (try...except) 119.1 544.67 P
+1 F
+0.25 ( form specifies one or more exception handlers \050the) 198.3 544.67 P
+2 F
+0.6 (except) 429.95 544.67 P
+1 F
+0.25 ( clauses\051. When) 469.55 544.67 P
+0.08 (no exception occurs in the) 99 531.67 P
+2 F
+0.19 (try) 217.62 531.67 P
+1 F
+0.08 ( clause, no exception handler is executed. When an exception occurs) 237.42 531.67 P
+-0.02 (in the) 99 518.67 P
+2 F
+-0.05 (try) 126.46 518.67 P
+1 F
+-0.02 ( suite, a search for an exception handler is started. This inspects the except clauses in turn) 146.26 518.67 P
+0.41 0 (until one is found that matches the exception. An expression-less except clause, if present, must be) 99 505.67 B
+0.03 (last; it matches any exception. For an except clause with an expression, that expression is evaluated,) 99 492.67 P
+0.41 0.01 (and the clause matches the exception if the resulting object is \322compatible\323 with the exception. An) 99 479.67 B
+-0.33 (object is compatible with an exception if it is either the object that identifies the exception, or \050for ex-) 99 466.67 P
+0.25 (ceptions that are classes\051 it is a base class of the exception, or it is a tuple containing an item that is) 99 453.67 P
+-0.28 (compatible with the exception. Note that the object identities must match, i.e. it must be the same ob-) 99 440.67 P
+(ject, not just an object with the same value.) 99 427.67 T
+0.36 (If no except clause matches the exception, the search for an exception handler continues in the sur-) 99 402.67 P
+(rounding code and on the invocation stack.) 99 389.67 T
+0.32 (If the evaluation of an expression in the header of an except clause raises an exception, the original) 99 364.67 P
+-0.41 (search for a handler is cancelled and a search starts for the new exception in the surrounding code and) 99 351.67 P
+(on the call stack \050it is treated as if the entire) 99 338.67 T
+2 F
+(try) 293.6 338.67 T
+1 F
+( statement raised the exception\051.) 313.4 338.67 T
+-0.29 (When a matching except clause is found, the exception\325s parameter is assigned to the target specified) 99 313.67 P
+0.08 (in that except clause, if present, and the except clause\325s suite is executed. When the end of this suite) 99 300.67 P
+-0.27 (is reached, execution continues normally after the entire try statement. \050This means that if two nested) 99 287.67 P
+-0.1 (handlers exist for the same exception, and the exception occurs in the try clause of the inner handler,) 99 274.67 P
+(the outer handler will not handle the exception.\051) 99 261.67 T
+-0.37 (Before an except clause\325s suite is executed, details about the exception are assigned to three variables) 99 236.67 P
+0.41 0.88 (in the) 99 223.67 B
+2 F
+0.99 0.88 (sys) 133.46 223.67 B
+1 F
+0.41 0.88 ( module:) 155.9 223.67 B
+2 F
+0.99 0.88 (sys.exc_type) 206.17 223.67 B
+1 F
+0.41 0.88 ( receives the object identifying the exception;) 295.9 223.67 B
+2 F
+0.99 0.05 (sys.exc_value) 99 210.67 B
+1 F
+0.41 0.05 ( receives the exception\325s parameter;) 185.49 210.67 B
+2 F
+0.99 0.05 (sys.exc_traceback) 350.49 210.67 B
+1 F
+0.41 0.05 ( receives a trace-) 463.6 210.67 B
+(back object \050see page) 99 197.67 T
+(17\051 identifying the point in the program where the exception occurred.) 196.13 197.67 T
+-0.36 (The optional) 99 172.67 P
+2 F
+-0.86 (else) 156.95 172.67 P
+1 F
+-0.36 ( clause is executed when no exception occurs in the) 183.35 172.67 P
+2 F
+-0.86 (try) 409.5 172.67 P
+1 F
+-0.36 ( clause. Exceptions in the) 429.3 172.67 P
+2 F
+(else) 99 159.67 T
+1 F
+( clause are not handled by the preceding) 125.4 159.67 T
+2 F
+(except) 305.02 159.67 T
+1 F
+( clauses.) 344.62 159.67 T
+-0.52 (The) 99 134.67 P
+2 F
+-1.26 (try...finally) 118.33 134.67 P
+1 F
+-0.52 ( form specifies a \324cleanup\325 handler. The) 204.13 134.67 P
+2 F
+-1.26 (try) 378.86 134.67 P
+1 F
+-0.52 ( clause is executed. When no ex-) 398.65 134.67 P
+0.4 (ception occurs, the) 99 121.67 P
+2 F
+0.96 (finally) 185.73 121.67 P
+1 F
+0.4 ( clause is executed. When an exception occurs in the) 231.93 121.67 P
+2 F
+0.96 (try) 470.22 121.67 P
+1 F
+0.4 ( clause, the) 490.02 121.67 P
+-0.09 (exception is temporarily saved, the) 99 108.67 P
+2 F
+-0.23 (finally) 254.95 108.67 P
+1 F
+-0.09 ( clause is executed, and then the saved exception is re-) 301.15 108.67 P
+-0.31 (raised. If the) 99 95.67 P
+2 F
+-0.76 (finally) 156.09 95.67 P
+1 F
+-0.31 ( clause raises another exception or executes a) 202.29 95.67 P
+2 F
+-0.76 (return) 401.98 95.67 P
+1 F
+-0.31 (,) 441.58 95.67 P
+2 F
+-0.76 (break) 446.77 95.67 P
+1 F
+-0.31 ( or) 479.77 95.67 P
+2 F
+-0.76 (contin-) 493.8 95.67 P
+(ue) 99 82.67 T
+1 F
+( statement, the saved exception is lost.) 112.2 82.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "47" 53
+%%Page: "48" 54
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(48) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.11 (When a) 72 712.67 P
+2 F
+0.26 (return) 108.87 712.67 P
+1 F
+0.11 ( or) 148.47 712.67 P
+2 F
+0.26 (break) 163.34 712.67 P
+1 F
+0.11 ( statement is executed in the) 196.34 712.67 P
+2 F
+0.26 (try) 324.08 712.67 P
+1 F
+0.11 ( suite of a) 343.88 712.67 P
+2 F
+0.26 (try...finally) 390.13 712.67 P
+1 F
+0.11 ( statement, the) 475.93 712.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 F
+0.95 (finally) 72 699.67 P
+1 F
+0.4 ( clause is also executed \324on the way out\325. A) 118.2 699.67 P
+2 F
+0.95 (continue) 316.14 699.67 P
+1 F
+0.4 ( statement is illegal in the) 368.94 699.67 P
+2 F
+0.95 (try) 486.82 699.67 P
+1 F
+0.4 ( clause.) 506.61 699.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\050The reason is a problem with the current implementation \321 this restriction may be lifted in the future\051.) 72 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(7.5) 72 659.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Function definitions) 108 659.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+2.8 (A function definition defines a user-defined function object \050see \322The standard type hierarchy\323 on) 72 634.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(page) 72 621.67 T
+(12\051) 95.52 621.67 T
+1 8.8 Q
+(1) 110.18 626.07 T
+1 11 Q
+(:) 114.58 621.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(funcdef:        "def" funcname "\050" [parameter_list] "\051" ":" suite) 72 603.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(parameter_list: \050defparameter ","\051* \050"*" identifier [, "**" identifier]) 72 591.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(                                    | "**" identifier) 72 579.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(                                    | defparameter [","]\051) 72 567.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(defparameter:   parameter ["=" expression]) 72 555.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(sublist:        parameter \050"," parameter\051* [","]) 72 543.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(parameter:      identifier | "\050" sublist "\051") 72 531.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(funcname:       identifier) 72 519.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.05 (A function definition is an executable statement. Its execution binds the function name in the current local) 72 494.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.04 (name space to a function object \050a wrapper around the executable code for the function\051. This function ob-) 72 481.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.06 (ject contains a reference to the current global name space as the global name space to be used when the) 72 468.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(function is called.) 72 455.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.41 0.04 (The function definition does not execute the function body; this gets executed only when the function is) 72 430.67 B
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(called.) 72 417.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.19 (When one or more top-level parameters have the form) 72 392.67 P
+3 F
+-0.19 (parameter = expression) 311.95 392.67 P
+1 F
+-0.19 (, the function is said to have) 417.38 392.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 (\322default parameter values\323. Default parameter values are evaluated when the function definition is execut-) 72 379.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.15 (ed. For a parameter with a default value, the correponding argument may be omitted from a call, in which) 72 366.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.46 (case the parameter\325s default value is substituted. If a parameter has a default value, all following parameters) 72 353.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(must also have a default value \321 this is a syntactic restriction that is not expressed by the grammar.) 72 340.67 T
+1 8.8 Q
+(2) 511.64 345.07 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.45 (Function call semantics are described in section \322Calls\323 on page) 72 315.67 P
+-0.45 (31. When a user-defined function is called,) 353.3 315.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.17 (first missing arguments for which a default value exists are supplied; then the arguments \050a.k.a. actual pa-) 72 302.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(rameters\051 are bound to the \050formal\051 parameters, as follows:) 72 289.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 270.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(If there are no formal parameters, there must be no arguments.) 86.4 270.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 251.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.55 (If the formal parameter list does not end in a star followed by an identifier, there must be exactly as many) 86.4 251.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.39 (arguments as there are parameters in the formal parameter list \050at the top level\051; the arguments are as-) 86.4 238.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.31 (signed to the formal parameters one by one. Note that the presence or absence of a trailing comma at the) 86.4 225.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.55 (top level in either the formal or the actual parameter list makes no difference. The assignment to a formal) 86.4 212.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.58 (parameter is performed as if the parameter occurs on the left hand side of an assignment statement whose) 86.4 199.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(right hand side\325s value is that of the argument.) 86.4 186.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(\245) 72 167.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0.34 (If the formal parameter list ends in a star followed by an identifier, preceded by zero or more comma-) 86.4 167.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.63 (followed parameters, there must be at least as many arguments as there are parameters preceding the star.) 86.4 154.67 P
+0 0 0 1 0 0 0 K
+72 124 540 139 C
+0 0 0 1 0 0 0 K
+81 137 225 137 2 L
+0.5 H
+2 Z
+0 X
+0 0 0 1 0 0 0 K
+N
+0 0 0 1 0 0 0 K
+0 0 612 792 C
+0 0 0 1 0 0 0 K
+1 11 Q
+0 X
+0 0 0 1 0 0 0 K
+(1.) 81 116.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+-0.3 (The new syntax to receive arbitrary keyword arguments is not yet documented in this manual. See) 94.5 116.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(chapter 12 of the Tutorial.) 94.46 103.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(2.) 81 90.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+6.81 (Currently this is not checked; instead,) 94.5 90.67 P
+2 F
+16.33 (def f\050a=1,b\051) 304.29 90.67 P
+1 F
+6.81 ( is interpreted as) 399.83 90.67 P
+2 F
+16.33 (def) 502.2 90.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(f\050a=1,b=None\051) 94.46 77.67 T
+1 F
+(.) 180.26 77.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "48" 54
+%%Page: "49" 55
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(49) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Compound statements) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.2 (Call this number) 113.4 712.67 P
+3 F
+-0.2 (N) 188.9 712.67 P
+1 F
+-0.2 (. The first) 196.23 712.67 P
+3 F
+-0.2 (N) 241.47 712.67 P
+1 F
+-0.2 ( arguments are assigned to the corresponding formal parameters in) 248.81 712.67 P
+0.33 (the way descibed above. A tuple containing the remaining arguments, if any, is then assigned to) 113.4 699.67 P
+0.58 (the identifier following the star. This variable will always be a tuple: if there are no extra argu-) 113.4 686.67 P
+(ments, its value is) 113.4 673.67 T
+2 F
+(\050\051) 194.99 673.67 T
+1 F
+(, if there is just one extra argument, it is a singleton tuple.) 208.19 673.67 T
+-0.1 (Note that the \324variable length parameter list\325 feature only works at the top level of the parameter list;) 99 648.67 P
+-0.15 (individual parameters use a model corresponding more closely to that of ordinary assignment. While) 99 635.67 P
+0.36 (the latter model is generally preferable, because of the greater type safety it offers \050wrong-sized tu-) 99 622.67 P
+0.18 (ples aren\325t silently mistreated\051, variable length parameter lists are a sufficiently accepted practice in) 99 609.67 P
+-0.37 (most programming languages that a compromise has been worked out. \050And anyway, assignment has) 99 596.67 P
+(no equivalent for empty argument lists.\051) 99 583.67 T
+-0.07 (It is also possible to create anonymous functions \050functions not bound to a name\051, for immediate use) 99 558.67 P
+(in expressions. This uses lambda forms, described in section \322Boolean operations\323 on page) 99 545.67 T
+(35.) 502.58 545.67 T
+0 14 Q
+(7.6) 99 518.67 T
+(Class definitions) 135 518.67 T
+1 11 Q
+(A class definition defines a class object \050see section \322The standard type hierarchy\323 on page) 99 493.67 T
+(12\051:) 502.54 493.67 T
+2 10 Q
+(classdef:       "class" classname [inheritance] ":" suite) 99 475.33 T
+(inheritance:    "\050" [expression_list] "\051") 99 463.33 T
+(classname:      identifier) 99 451.33 T
+1 11 Q
+0.41 0.05 (A class definition is an executable statement. It first evaluates the inheritance list, if present. Each) 99 426.67 B
+-0.52 (item in the inheritance list should evaluate to a class object. The class\325s suite is then executed in a new) 99 413.67 P
+-0.27 (execution frame \050see section \322Code blocks, execution frames, and name spaces\323 on page) 99 400.67 P
+-0.27 (23\051, using a) 488.9 400.67 P
+-0.11 (newly created local name space and the original global name space. \050Usually, the suite contains only) 99 387.67 P
+0.25 (function definitions.\051 When the class\325s suite finishes execution, its execution frame is discarded but) 99 374.67 P
+0.41 0.09 (its local name space is saved. A class object is then created using the inheritance list for the base) 99 361.67 B
+0.41 0.01 (classes and the saved local name space for the attribute dictionary. The class name is bound to this) 99 348.67 B
+(class object in the original local name space.) 99 335.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "49" 55
+%%Page: "50" 56
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(50) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "50" 56
+%%Page: "51" 57
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(51) 530 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+585 292.5 598.5 720 R
+5 9 Q
+(\245) 0 -90 592.5 720 TF
+(Top-level components) 0 -90 592.5 711 TF
+585 292.5 598.5 720 R
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 16 Q
+(C) 99 709.33 T
+0 12.8 Q
+(HAPTER) 110.55 709.33 T
+0 16 Q
+(8:) 167.62 709.33 T
+(T) 198 709.33 T
+0 12.8 Q
+(OP) 207.78 709.33 T
+0 16 Q
+(-) 226.27 709.33 T
+0 12.8 Q
+(LEVEL) 231.6 709.33 T
+(COMPONENTS) 277.3 709.33 T
+1 11 Q
+0.14 (The Python interpreter can get its input from a number of sources: from a script passed to it as stan-) 99 672.67 P
+-0.54 (dard input or as program argument, typed in interactively, from a module source file, etc. This chapter) 99 659.67 P
+(gives the syntax used in these cases.) 99 646.67 T
+0 14 Q
+(8.1) 99 619.67 T
+(Complete Python programs) 135 619.67 T
+1 11 Q
+-0.46 (While a language specification need not prescribe how the language interpreter is invoked, it is useful) 99 594.67 P
+0.35 (to have a notion of a complete Python program. A complete Python program is executed in a mini-) 99 581.67 P
+-0.51 (mally initialized environment: all built-in and standard modules are available, but none have been ini-) 99 568.67 P
+0.92 (tialized, except for) 99 555.67 P
+2 F
+2.2 (sys) 186.68 555.67 P
+1 F
+0.92 ( \050various system services\051,) 206.48 555.67 P
+2 F
+2.2 (__builtin__) 329.6 555.67 P
+1 F
+0.92 ( \050built-in functions, exceptions) 402.2 555.67 P
+-0.06 (and) 99 542.67 P
+2 F
+-0.16 (None) 117.57 542.67 P
+1 F
+-0.06 (\051 and) 143.97 542.67 P
+2 F
+-0.16 (__main__) 168.88 542.67 P
+1 F
+-0.06 (. The latter is used to provide the local and global name space for execu-) 221.68 542.67 P
+(tion of the complete program.) 99 529.67 T
+(The syntax for a complete Python program is that for file input, described in the next section.) 99 504.67 T
+0.21 (The interpreter may also be invoked in interactive mode; in this case, it does not read and execute a) 99 479.67 P
+0.41 0.02 (complete program but reads and executes one statement \050possibly compound\051 at a time. The initial) 99 466.67 B
+-0.16 (environment is identical to that of a complete program; each statement is executed in the name space) 99 453.67 P
+(of) 99 440.67 T
+2 F
+(__main__) 110.91 440.67 T
+1 F
+(.) 163.71 440.67 T
+0.11 (Under UNIX , a complete program can be passed to the interpreter in three forms: with the) 99 415.67 P
+4 F
+0.11 (-c) 502.92 415.67 P
+3 F
+0.11 (string) 514.33 415.67 P
+1 F
+-0.2 (command line option, as a file passed as the first command line argument, or as standard input. If the) 99 402.67 P
+-0.28 (file or standard input is a tty device, the interpreter enters interactive mode; otherwise, it executes the) 99 389.67 P
+(file as a complete program.) 99 376.67 T
+0 14 Q
+(8.2) 99 349.67 T
+(File input) 135 349.67 T
+1 11 Q
+(All input read from non-interactive files has the same form:) 99 324.67 T
+2 10 Q
+(file_input:     \050NEWLINE | statement\051*) 99 306.33 T
+1 11 Q
+(This syntax is used in the following situations:) 99 281.67 T
+(\245) 99 262.67 T
+(when parsing a complete Python program \050from a file or from a string\051;) 113.4 262.67 T
+(\245) 99 243.67 T
+(when parsing a module;) 113.4 243.67 T
+(\245) 99 224.67 T
+(when parsing a string passed to the) 113.4 224.67 T
+2 F
+(exec) 270.13 224.67 T
+1 F
+( statement;) 296.53 224.67 T
+0 14 Q
+(8.3) 99 197.67 T
+(Interactive input) 135 197.67 T
+1 11 Q
+(Input in interactive mode is parsed using the following grammar:) 99 172.67 T
+2 10 Q
+(interactive_input: [stmt_list] NEWLINE | compound_stmt NEWLINE) 99 154.33 T
+1 11 Q
+-0.43 (Note that a \050top-level\051 compound statement must be followed by a blank line in interactive mode; this) 99 129.67 P
+(is needed to help the parser detect the end of the input.) 99 116.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "51" 57
+%%Page: "52" 58
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(52) 76.5 37.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 14 Q
+(8.4) 72 710.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(Expression input) 108 710.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+-0.1 (There are two forms of expression input. Both ignore leading whitespace. The string argument to) 72 685.67 P
+2 F
+-0.23 (eval\050\051) 500.4 685.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 F
+(must have the following form:) 72 672.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(eval_input:     expression_list NEWLINE*) 72 654.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(The input line read by) 72 629.67 T
+2 F
+(input\050\051) 171.9 629.67 T
+1 F
+( must have the following form:) 218.1 629.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+2 10 Q
+(input_input:    expression_list NEWLINE) 72 611.33 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+0.37 (Note: to read \324raw\325 input line without interpretation, you can use the built-in function) 72 586.67 P
+2 F
+0.89 (raw_input\050\051) 455.12 586.67 P
+1 F
+0.37 ( or) 527.72 586.67 P
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(the) 72 573.67 T
+2 F
+(readline\050\051) 88.19 573.67 T
+1 F
+( method of file objects.) 154.19 573.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "52" 58
+%%Page: "53" 59
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+1 10 Q
+0 X
+0 0 0 1 0 0 0 K
+(53) 525.5 32.83 T
+0 0 0 1 0 0 0 K
+315 639 315 63 2 L
+0.5 H
+2 Z
+N
+85.5 639 85.5 63 2 L
+N
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+(Symbols) 94.5 631 T
+1 11 Q
+(#) 94.5 617.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . . . . .) 104.5 617.67 T
+(3) 264.5 617.67 T
+(__abs__) 94.5 604.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 604.67 T
+(22) 259 604.67 T
+(__add__) 94.5 591.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 591.67 T
+(21) 259 591.67 T
+(__and__) 94.5 578.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 578.67 T
+(21) 259 578.67 T
+(__bases__) 94.5 565.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 145.75 565.67 T
+(16) 259 565.67 T
+(__builtin__) 94.5 552.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 552.67 T
+(24) 242 552.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 552.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(51) 259 552.67 T
+(__builtins__) 94.5 539.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 539.67 T
+(24) 259 539.67 T
+(__call__) 94.5 526.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 137.5 526.67 T
+(15) 242 526.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 526.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(20) 259 526.67 T
+(__class__) 94.5 513.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 143 513.67 T
+(16) 259 513.67 T
+(__cmp__) 94.5 500.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 140.25 500.67 T
+(19) 259 500.67 T
+(__coerce__) 94.5 487.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 148.5 487.67 T
+(22) 259 487.67 T
+(__del__) 94.5 474.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 474.67 T
+(18) 259 474.67 T
+(exception in) 112.5 461.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 170.5 461.67 T
+(18) 259 461.67 T
+(__delattr__) 94.5 448.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 448.67 T
+(16) 242 448.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 448.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(20) 259 448.67 T
+(__delitem__) 94.5 435.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 435.67 T
+(20) 259 435.67 T
+(__delslice__) 94.5 422.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 422.67 T
+(21) 259 422.67 T
+(__dict__) 94.5 409.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 137.5 409.67 T
+(15) 225 409.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 236 409.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 242 409.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 409.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(20) 259 409.67 T
+(__div__) 94.5 396.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 396.67 T
+(21) 259 396.67 T
+(__divmod__) 94.5 383.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 383.67 T
+(21) 259 383.67 T
+(__doc__) 94.5 370.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 137.5 370.67 T
+(14) 242 370.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 253 370.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 259 370.67 T
+(__file__) 94.5 357.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 357.67 T
+(15) 259 357.67 T
+(__float__) 94.5 344.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 140.25 344.67 T
+(22) 259 344.67 T
+(__getattr__) 94.5 331.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 331.67 T
+(16) 242 331.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 331.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(19) 259 331.67 T
+(__getitem__) 94.5 318.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 154 318.67 T
+(18) 242 318.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 318.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(20) 259 318.67 T
+(__getslice__) 94.5 305.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 305.67 T
+(20) 259 305.67 T
+(__hash__) 94.5 292.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 140.25 292.67 T
+(19) 259 292.67 T
+(__hex__) 94.5 279.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 279.67 T
+(22) 259 279.67 T
+(__init__) 94.5 266.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 134.75 266.67 T
+(15) 242 266.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 266.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(18) 259 266.67 T
+(__int__) 94.5 253.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 132 253.67 T
+(22) 259 253.67 T
+(__invert__) 94.5 240.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 145.75 240.67 T
+(22) 259 240.67 T
+(__len__) 94.5 227.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 134.75 227.67 T
+(19) 242 227.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 253 227.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(20) 259 227.67 T
+(__long__) 94.5 214.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 140.25 214.67 T
+(22) 259 214.67 T
+(__lshift__) 94.5 201.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 143 201.67 T
+(21) 259 201.67 T
+(__main__) 94.5 188.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 143 188.67 T
+(24) 242 188.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 188.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(51) 259 188.67 T
+(__members__) 94.5 175.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 162.25 175.67 T
+(12) 259 175.67 T
+(__methods__) 94.5 162.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 159.5 162.67 T
+(12) 259 162.67 T
+(__mod__) 94.5 149.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 140.25 149.67 T
+(21) 259 149.67 T
+(__mul__) 94.5 136.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 136.67 T
+(21) 259 136.67 T
+(__name__) 94.5 123.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 145.75 123.67 T
+(14) 242 123.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 253 123.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 259 123.67 T
+(__neg__) 94.5 110.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 110.67 T
+(21) 259 110.67 T
+(__nonzero__) 94.5 97.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . .) 156.75 97.67 T
+(19) 242 97.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 253 97.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(20) 259 97.67 T
+(__oct__) 94.5 84.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 84.67 T
+(22) 259 84.67 T
+(__or__) 94.5 71.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 129.25 71.67 T
+(21) 259 71.67 T
+(__pos__) 324 631.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 365.75 631.67 T
+(21) 488.5 631.67 T
+(__pow__) 324 618.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 368.5 618.67 T
+(21) 488.5 618.67 T
+(__radd__) 324 605.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 371.25 605.67 T
+(21) 488.5 605.67 T
+(__rand__) 324 592.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 371.25 592.67 T
+(21) 488.5 592.67 T
+(__rdiv__) 324 579.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 368.5 579.67 T
+(21) 488.5 579.67 T
+(__rdivmod__) 324 566.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 387.75 566.67 T
+(21) 488.5 566.67 T
+(__repr__) 324 553.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 368.5 553.67 T
+(18) 471.5 553.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 482.5 553.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(19) 488.5 553.67 T
+(__rlshift__) 324 540.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 376.75 540.67 T
+(21) 488.5 540.67 T
+(__rmod__) 324 527.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 374 527.67 T
+(21) 488.5 527.67 T
+(__rmul__) 324 514.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 371.25 514.67 T
+(21) 488.5 514.67 T
+(__ror__) 324 501.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 363 501.67 T
+(21) 488.5 501.67 T
+(__rpow__) 324 488.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 374 488.67 T
+(21) 488.5 488.67 T
+(__rrshift__) 324 475.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 376.75 475.67 T
+(21) 488.5 475.67 T
+(__rshift__) 324 462.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 374 462.67 T
+(21) 488.5 462.67 T
+(__rsub__) 324 449.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 368.5 449.67 T
+(21) 488.5 449.67 T
+(__rxor__) 324 436.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 368.5 436.67 T
+(21) 488.5 436.67 T
+(__self__) 324 423.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 365.75 423.67 T
+(15) 488.5 423.67 T
+(__setattr__) 324 410.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 376.75 410.67 T
+(16) 471.5 410.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 410.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(19) 488.5 410.67 T
+(__setitem__) 324 397.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 397.67 T
+(20) 488.5 397.67 T
+(__setslice__) 324 384.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 384.67 T
+(20) 488.5 384.67 T
+(__str__) 324 371.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 360.25 371.67 T
+(19) 488.5 371.67 T
+(__sub__) 324 358.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 365.75 358.67 T
+(21) 488.5 358.67 T
+(__xor__) 324 345.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 365.75 345.67 T
+(21) 488.5 345.67 T
+0 12 Q
+(A) 324 324 T
+1 11 Q
+(abstraction) 324 310.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 376.75 310.67 T
+(11) 488.5 310.67 T
+(actual) 324 297.67 T
+(parameter) 342 284.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 390.5 284.67 T
+(48) 488.5 284.67 T
+(addition) 324 271.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 365.75 271.67 T
+(33) 488.5 271.67 T
+(and) 324 258.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . . .) 343.75 258.67 T
+(35) 488.5 258.67 T
+(bit-wise) 342 245.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 245.67 T
+(34) 488.5 245.67 T
+(argument) 324 232.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 371.25 232.67 T
+(48) 488.5 232.67 T
+(default value) 342 219.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . .) 404.25 219.67 T
+(31) 488.5 219.67 T
+(function) 342 206.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 206.67 T
+(14) 488.5 206.67 T
+(keyword) 342 193.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 385 193.67 T
+(31) 488.5 193.67 T
+(arguments) 324 180.67 T
+(positional) 342 167.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 390.5 167.67 T
+(31) 488.5 167.67 T
+(array of bytes) 324 154.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 387.75 154.67 T
+(13) 488.5 154.67 T
+(ASCII) 324 141.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 357.5 141.67 T
+(1) 442.5 141.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 448 141.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(6) 454 141.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 459.5 141.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(7) 465.5 141.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 471 141.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(9) 477 141.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 141.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(13) 488.5 141.67 T
+(assignment) 324 128.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 376.75 128.67 T
+(13) 471.5 128.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 128.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 488.5 128.67 T
+(attribute) 342 115.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 115.67 T
+(40) 488.5 115.67 T
+(class) 360 102.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 385 102.67 T
+(16) 488.5 102.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+4.8 (I) 288 670 S
+0 9.6 Q
+4.8 (NDEX) 296.13 670 S
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "53" 59
+%%Page: "54" 60
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 12 Q
+0 X
+0 0 0 1 0 0 0 K
+4.8 (I) 270 748 S
+0 9.6 Q
+4.8 (NDEX) 278.13 748 S
+0 0 0 1 0 0 0 K
+1 10 Q
+(54) 76.5 32.83 T
+0 0 0 1 0 0 0 K
+297 720 297 63 2 L
+0.5 H
+2 Z
+N
+67.5 720 67.5 63 2 L
+N
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(class instance) 112.5 712.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . .) 176 712.67 T
+(16) 241 712.67 T
+(attributes) 94.5 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 140.25 699.67 T
+(39) 241 699.67 T
+(formal parameter) 94.5 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . .) 176 686.67 T
+(48) 241 686.67 T
+(list) 94.5 673.67 T
+(target) 112.5 660.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 143 660.67 T
+(40) 241 660.67 T
+(slicing) 94.5 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 129.25 647.67 T
+(40) 241 647.67 T
+(subscription) 94.5 634.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 154 634.67 T
+(40) 241 634.67 T
+(atom) 76.5 621.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . .) 101.75 621.67 T
+(27) 241 621.67 T
+(attribute) 76.5 608.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 118.25 608.67 T
+(12) 241 608.67 T
+(class) 94.5 595.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 121 595.67 T
+(16) 241 595.67 T
+(class instance) 94.5 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 159.5 582.67 T
+(16) 241 582.67 T
+(generic) 94.5 569.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 132 569.67 T
+(12) 241 569.67 T
+(special) 94.5 556.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 129.25 556.67 T
+(12) 241 556.67 T
+(attribute access) 76.5 543.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 543.67 T
+(19) 241 543.67 T
+(attribute search) 76.5 530.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 530.67 T
+(15) 241 530.67 T
+(AttributeError) 76.5 517.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . .) 143 517.67 T
+(19) 207 517.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 218 517.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 224 517.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 517.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 241 517.67 T
+0 12 Q
+(B) 76.5 496 T
+1 11 Q
+(back-quotes) 76.5 482.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 134.75 482.67 T
+(18) 224 482.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 482.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 241 482.67 T
+(backslash) 76.5 469.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 123.75 469.67 T
+(6) 246.5 469.67 T
+(backslash character) 76.5 456.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 167.75 456.67 T
+(3) 246.5 456.67 T
+(binary arithmetic operations) 76.5 443.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . .) 206.25 443.67 T
+(21) 241 443.67 T
+(binding) 76.5 430.67 T
+(name) 94.5 417.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . .) 123.75 417.67 T
+(27) 190 417.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 201 417.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 207 417.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 218 417.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(48) 224 417.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 235 417.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(49) 241 417.67 T
+(global) 112.5 404.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 143 404.67 T
+(44) 241 404.67 T
+(bitwise operations) 76.5 391.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 162.25 391.67 T
+(21) 241 391.67 T
+(blank line) 76.5 378.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 123.75 378.67 T
+(4) 246.5 378.67 T
+(block) 76.5 365.67 T
+(code) 94.5 352.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 121 352.67 T
+(23) 241 352.67 T
+(BNF) 76.5 339.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 101.75 339.67 T
+(1) 229.5 339.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 339.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 241 339.67 T
+(break) 76.5 326.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 104.5 326.67 T
+(42) 207 326.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 218 326.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 224 326.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 235 326.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(47) 241 326.67 T
+(built-in) 76.5 313.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 112.75 313.67 T
+(15) 224 313.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 313.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(32) 241 313.67 T
+(built-in method) 76.5 300.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 300.67 T
+(32) 241 300.67 T
+(byte) 76.5 287.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 99 287.67 T
+(13) 241 287.67 T
+(bytecode) 76.5 274.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 121 274.67 T
+(16) 241 274.67 T
+(byte-compile) 76.5 261.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 140.25 261.67 T
+(16) 241 261.67 T
+0 12 Q
+(C) 76.5 240 T
+1 11 Q
+(C) 76.5 226.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 88 226.67 T
+(7) 178.5 226.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 184 226.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(12) 190 226.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 201 226.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(15) 207 226.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 218 226.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 224 226.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 226.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(34) 241 226.67 T
+(call) 76.5 213.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . . .) 96.25 213.67 T
+(31) 241 213.67 T
+(built-in function) 94.5 200.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . .) 170.5 200.67 T
+(32) 241 200.67 T
+(built-in method) 94.5 187.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . .) 167.75 187.67 T
+(32) 241 187.67 T
+(class instance) 94.5 174.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 159.5 174.67 T
+(32) 241 174.67 T
+(class object) 94.5 161.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . .) 151.25 161.67 T
+(15) 207 161.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 218 161.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 224 161.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 161.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(32) 241 161.67 T
+(function) 94.5 148.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 134.75 148.67 T
+(32) 224 148.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 148.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(48) 241 148.67 T
+(user-defined) 112.5 135.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . .) 170.5 135.67 T
+(32) 224 135.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 135.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(48) 241 135.67 T
+(function invocation) 94.5 122.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . .) 184.25 122.67 T
+(14) 241 122.67 T
+(instance) 94.5 109.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 134.75 109.67 T
+(32) 241 109.67 T
+(method) 94.5 96.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 132 96.67 T
+(32) 241 96.67 T
+(procedure) 94.5 83.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 143 83.67 T
+(39) 241 83.67 T
+(callable) 76.5 70.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 115.5 70.67 T
+(14) 224 70.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 70.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(31) 241 70.67 T
+(characters) 306 712.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 354.75 712.67 T
+(30) 470.5 712.67 T
+(chr) 306 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . . .) 324.5 699.67 T
+(13) 470.5 699.67 T
+(circular references) 306 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 393.25 686.67 T
+(11) 470.5 686.67 T
+(class) 306 673.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . .) 332.75 673.67 T
+(15) 419.5 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 430.5 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 436.5 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(32) 453.5 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(49) 470.5 673.67 T
+(class instance) 306 660.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 371.25 660.67 T
+(15) 470.5 660.67 T
+(clause) 306 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 338.25 647.67 T
+(45) 470.5 647.67 T
+(close) 306 634.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . .) 332.75 634.67 T
+(11) 470.5 634.67 T
+(code block) 306 621.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . .) 357.5 621.67 T
+(23) 419.5 621.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 430.5 621.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 436.5 621.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 621.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 453.5 621.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 464.5 621.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(44) 470.5 621.67 T
+(code generation phase) 306 608.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . .) 407 608.67 T
+(41) 470.5 608.67 T
+(code object) 306 595.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 360.25 595.67 T
+(16) 470.5 595.67 T
+(co_argcount) 324 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 582.67 T
+(17) 470.5 582.67 T
+(co_code) 324 569.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 365.75 569.67 T
+(17) 470.5 569.67 T
+(co_consts) 324 556.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 371.25 556.67 T
+(17) 470.5 556.67 T
+(co_filename) 324 543.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 543.67 T
+(17) 470.5 543.67 T
+(co_flags) 324 530.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 365.75 530.67 T
+(17) 470.5 530.67 T
+(co_names) 324 517.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 371.25 517.67 T
+(17) 470.5 517.67 T
+(co_nlocals) 324 504.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 376.75 504.67 T
+(17) 470.5 504.67 T
+(co_varnames) 324 491.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . .) 387.75 491.67 T
+(17) 470.5 491.67 T
+(coercion) 306 478.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 349.25 478.67 T
+(27) 453.5 478.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 478.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(32) 470.5 478.67 T
+(coercion rules) 306 465.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 371.25 465.67 T
+(22) 470.5 465.67 T
+(colon) 306 452.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 335.5 452.67 T
+(45) 470.5 452.67 T
+(comma) 306 439.67 T
+(trailing) 324 426.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 360.25 426.67 T
+(36) 453.5 426.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 426.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(42) 470.5 426.67 T
+(comma operator) 306 413.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 413.67 T
+(28) 470.5 413.67 T
+(command line) 306 400.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 374 400.67 T
+(51) 470.5 400.67 T
+(comment) 306 387.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 352 387.67 T
+(3) 476 387.67 T
+(comparison) 306 374.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 363 374.67 T
+(34) 470.5 374.67 T
+(chaining) 324 361.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 365.75 361.67 T
+(34) 470.5 361.67 T
+(comparison operator) 306 348.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . .) 401.5 348.67 T
+(9) 476 348.67 T
+(compile) 306 335.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 346.5 335.67 T
+(44) 470.5 335.67 T
+(complex literal) 306 322.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 376.75 322.67 T
+(8) 476 322.67 T
+(complex number) 306 309.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . .) 385 309.67 T
+(9) 442 309.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 309.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(13) 453.5 309.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 309.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 470.5 309.67 T
+(constant) 306 296.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . .) 346.5 296.67 T
+(6) 476 296.67 T
+(constructor) 306 283.67 T
+(class) 324 270.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 349.25 270.67 T
+(18) 470.5 270.67 T
+(container) 306 257.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 352 257.67 T
+(11) 453.5 257.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 257.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 470.5 257.67 T
+(continue) 306 244.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . .) 349.25 244.67 T
+(43) 436.5 244.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 244.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 453.5 244.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 464.5 244.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(47) 470.5 244.67 T
+(conversion) 306 231.67 T
+(arithmetic) 324 218.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 374 218.67 T
+(27) 470.5 218.67 T
+(string) 324 205.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 354.75 205.67 T
+(18) 436.5 205.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 205.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 453.5 205.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 205.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(39) 470.5 205.67 T
+(curly brace) 306 192.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 360.25 192.67 T
+(4) 476 192.67 T
+0 12 Q
+(D) 306 171 T
+1 11 Q
+(data) 306 157.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 330 157.67 T
+(11) 470.5 157.67 T
+(datum) 306 144.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 338.25 144.67 T
+(28) 470.5 144.67 T
+(debugger) 306 131.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 352 131.67 T
+(17) 470.5 131.67 T
+(debugging) 306 118.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 357.5 118.67 T
+(11) 470.5 118.67 T
+(decimal literal) 306 105.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 374 105.67 T
+(8) 476 105.67 T
+(DEDENT token) 306 92.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . .) 382.25 92.67 T
+(4) 459 92.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 92.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(45) 470.5 92.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "54" 60
+%%Page: "55" 61
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+0 X
+0 0 0 1 0 0 0 K
+4.8 (I) 288 748 S
+0 9.6 Q
+4.8 (NDEX) 296.13 748 S
+0 0 0 1 0 0 0 K
+1 10 Q
+(55) 525.5 32.83 T
+0 0 0 1 0 0 0 K
+315 720 315 63 2 L
+0.5 H
+2 Z
+N
+85.5 720 85.5 63 2 L
+N
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(definition) 94.5 712.67 T
+(class) 112.5 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 137.5 699.67 T
+(42) 242 699.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 699.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(49) 259 699.67 T
+(function) 112.5 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 154 686.67 T
+(42) 242 686.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 686.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(48) 259 686.67 T
+(del) 94.5 673.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 112.75 673.67 T
+(13) 191 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 202 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(18) 208 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 219 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(23) 225 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 236 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 242 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(41) 259 673.67 T
+(delete) 94.5 660.67 T
+(attribute) 112.5 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 647.67 T
+(41) 259 647.67 T
+(delimiter) 94.5 634.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 137.5 634.67 T
+(9) 264.5 634.67 T
+(dictionary) 94.5 621.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . .) 143 621.67 T
+(14) 174 621.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 185 621.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(15) 191 621.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 202 621.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(19) 208 621.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 219 621.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(28) 225 621.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 236 621.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 242 621.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 621.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 259 621.67 T
+(display) 94.5 608.67 T
+(dictionary) 112.5 595.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 162.25 595.67 T
+(28) 259 595.67 T
+(tuple) 112.5 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 582.67 T
+(28) 259 582.67 T
+(division) 94.5 569.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 569.67 T
+(33) 259 569.67 T
+(divmod) 94.5 556.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 132 556.67 T
+(33) 259 556.67 T
+(double precision) 94.5 543.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . .) 173.25 543.67 T
+(12) 259 543.67 T
+0 12 Q
+(E) 94.5 522 T
+1 11 Q
+(elif) 94.5 508.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . . .) 112.75 508.67 T
+(45) 259 508.67 T
+(Ellipsis) 94.5 495.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 132 495.67 T
+(12) 259 495.67 T
+(ellipsis) 94.5 482.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 129.25 482.67 T
+(17) 259 482.67 T
+(else) 94.5 469.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 115.5 469.67 T
+(42) 225 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 236 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(45) 242 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 253 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(47) 259 469.67 T
+(dangling) 112.5 456.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 456.67 T
+(45) 259 456.67 T
+(end-of-line character) 94.5 443.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . .) 189.75 443.67 T
+(3) 264.5 443.67 T
+(error) 94.5 430.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 121 430.67 T
+(25) 259 430.67 T
+(error handling) 94.5 417.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 162.25 417.67 T
+(25) 259 417.67 T
+(escape sequence) 94.5 404.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 170.5 404.67 T
+(7) 264.5 404.67 T
+(eval) 94.5 391.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 118.25 391.67 T
+(23) 208 391.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 219 391.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 225 391.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 236 391.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(44) 242 391.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 391.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(52) 259 391.67 T
+(except) 94.5 378.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . .) 126.5 378.67 T
+(47) 259 378.67 T
+(except clause) 94.5 365.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 156.75 365.67 T
+(23) 259 365.67 T
+(exception) 94.5 352.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 143 352.67 T
+(25) 242 352.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 352.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(42) 259 352.67 T
+(class) 112.5 339.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 339.67 T
+(47) 259 339.67 T
+(raised by comparisons) 112.5 326.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . .) 214.5 326.67 T
+(19) 259 326.67 T
+(raising) 112.5 313.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 145.75 313.67 T
+(42) 259 313.67 T
+(exception handler) 94.5 300.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . .) 178.75 300.67 T
+(25) 242 300.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 300.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(47) 259 300.67 T
+(exec) 94.5 287.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 118.25 287.67 T
+(23) 242 287.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 287.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(44) 259 287.67 T
+(execfile) 94.5 274.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 134.75 274.67 T
+(23) 242 274.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 274.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(44) 259 274.67 T
+(execution model) 94.5 261.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . .) 173.25 261.67 T
+(23) 259 261.67 T
+(expression) 94.5 248.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 145.75 248.67 T
+(27) 242 248.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 248.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 259 248.67 T
+(lambda) 112.5 235.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 148.5 235.67 T
+(35) 259 235.67 T
+(expression input) 94.5 222.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 170.5 222.67 T
+(52) 259 222.67 T
+(expression list) 94.5 209.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 162.25 209.67 T
+(36) 242 209.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 209.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(39) 259 209.67 T
+(extended slice notation) 94.5 196.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . .) 200.75 196.67 T
+(21) 259 196.67 T
+(extended slice syntax) 94.5 183.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . .) 192.5 183.67 T
+(17) 259 183.67 T
+(extension) 94.5 170.67 T
+(filename) 112.5 157.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 157.67 T
+(43) 259 157.67 T
+0 12 Q
+(F) 94.5 136 T
+1 11 Q
+(fdopen) 94.5 122.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 129.25 122.67 T
+(16) 259 122.67 T
+(file) 94.5 109.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 112.75 109.67 T
+(16) 242 109.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 109.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(52) 259 109.67 T
+(finally) 94.5 96.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 126.5 96.67 T
+(11) 225 96.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 236 96.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(42) 242 96.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 96.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(47) 259 96.67 T
+(floating point) 94.5 83.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 159.5 83.67 T
+(12) 259 83.67 T
+(floating point literal) 94.5 70.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . .) 187 70.67 T
+(8) 264.5 70.67 T
+(floating point number) 324 712.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . .) 423.5 712.67 T
+(27) 488.5 712.67 T
+(floor) 324 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . .) 349.25 699.67 T
+(33) 488.5 699.67 T
+(flow of control) 324 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 393.25 686.67 T
+(25) 488.5 686.67 T
+(for) 324 673.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 341 673.67 T
+(23) 437.5 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 448.5 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(42) 454.5 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 465.5 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 471.5 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 488.5 673.67 T
+(form) 324 660.67 T
+(lambda) 342 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 379.5 647.67 T
+(35) 488.5 647.67 T
+(formal) 324 634.67 T
+(parameter) 342 621.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 390.5 621.67 T
+(48) 488.5 621.67 T
+(formfeed character) 324 608.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 412.5 608.67 T
+(4) 494 608.67 T
+(frame) 324 595.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 354.75 595.67 T
+(17) 488.5 595.67 T
+(execution) 342 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 390.5 582.67 T
+(23) 471.5 582.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 582.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(49) 488.5 582.67 T
+(frame object) 324 569.67 T
+(f_back) 342 556.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 376.75 556.67 T
+(17) 488.5 556.67 T
+(f_builtins) 342 543.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 387.75 543.67 T
+(17) 488.5 543.67 T
+(f_code) 342 530.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 376.75 530.67 T
+(17) 488.5 530.67 T
+(f_globals) 342 517.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 387.75 517.67 T
+(17) 488.5 517.67 T
+(f_lasti) 342 504.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 374 504.67 T
+(17) 488.5 504.67 T
+(f_lineno) 342 491.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 491.67 T
+(17) 488.5 491.67 T
+(f_locals) 342 478.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 478.67 T
+(17) 488.5 478.67 T
+(f_owner) 342 465.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 465.67 T
+(17) 488.5 465.67 T
+(f_restricted) 342 452.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 396 452.67 T
+(17) 488.5 452.67 T
+(f_trace) 342 439.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 376.75 439.67 T
+(17) 488.5 439.67 T
+(from) 324 426.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 349.25 426.67 T
+(6) 460 426.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 465.5 426.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(23) 471.5 426.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 426.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 488.5 426.67 T
+(from x import *) 324 413.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 398.75 413.67 T
+(43) 488.5 413.67 T
+(function) 324 400.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 365.75 400.67 T
+(14) 454.5 400.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 465.5 400.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(32) 471.5 400.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 400.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(48) 488.5 400.67 T
+(anonymous) 342 387.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 396 387.67 T
+(35) 488.5 387.67 T
+(built-in) 342 374.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 379.5 374.67 T
+(15) 488.5 374.67 T
+(user-defined) 342 361.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . .) 401.5 361.67 T
+(14) 471.5 361.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 361.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(48) 488.5 361.67 T
+(function object) 324 348.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 396 348.67 T
+(16) 488.5 348.67 T
+(func_code) 342 335.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 393.25 335.67 T
+(14) 488.5 335.67 T
+(func_defaults) 342 322.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 407 322.67 T
+(14) 488.5 322.67 T
+(func_doc) 342 309.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 387.75 309.67 T
+(14) 488.5 309.67 T
+(func_globals) 342 296.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . .) 404.25 296.67 T
+(14) 471.5 296.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 482.5 296.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(15) 488.5 296.67 T
+(func_name) 342 283.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 396 283.67 T
+(14) 488.5 283.67 T
+0 12 Q
+(G) 324 262 T
+1 11 Q
+(garbage collection) 324 248.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 409.75 248.67 T
+(11) 488.5 248.67 T
+(getlineno) 324 235.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 368.5 235.67 T
+(17) 488.5 235.67 T
+(global) 324 222.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . .) 354.75 222.67 T
+(23) 403.5 222.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 414.5 222.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 420.5 222.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 431.5 222.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 437.5 222.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 448.5 222.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(41) 454.5 222.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 465.5 222.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 471.5 222.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 482.5 222.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(44) 488.5 222.67 T
+(globals) 324 209.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 360.25 209.67 T
+(24) 471.5 209.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 209.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(44) 488.5 209.67 T
+(grammar) 324 196.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 368.5 196.67 T
+(1) 494 196.67 T
+0 12 Q
+(H) 324 175 T
+1 11 Q
+(handle an exception) 324 161.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . .) 415.25 161.67 T
+(25) 488.5 161.67 T
+(handler) 324 148.67 T
+(exception) 342 135.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 390.5 135.67 T
+(17) 488.5 135.67 T
+(hash) 324 122.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . .) 349.25 122.67 T
+(19) 488.5 122.67 T
+(hash character) 324 109.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 390.5 109.67 T
+(3) 494 109.67 T
+(hexadecimal literal) 324 96.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 412.5 96.67 T
+(8) 494 96.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "55" 61
+%%Page: "56" 62
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 12 Q
+0 X
+0 0 0 1 0 0 0 K
+4.8 (I) 270 748 S
+0 9.6 Q
+4.8 (NDEX) 278.13 748 S
+0 0 0 1 0 0 0 K
+1 10 Q
+(56) 76.5 32.83 T
+0 0 0 1 0 0 0 K
+297 720 297 63 2 L
+0.5 H
+2 Z
+N
+67.5 720 67.5 63 2 L
+N
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+(I) 76.5 712 T
+1 11 Q
+(id) 76.5 698.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . . . .) 90.75 698.67 T
+(11) 241 698.67 T
+(Identifier) 76.5 685.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 121 685.67 T
+(5) 246.5 685.67 T
+(identifier) 76.5 672.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 121 672.67 T
+(27) 241 672.67 T
+(special meaning) 94.5 659.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . .) 170.5 659.67 T
+(6) 246.5 659.67 T
+(if) 76.5 646.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . . . .) 88 646.67 T
+(45) 241 646.67 T
+(im_class) 76.5 633.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 118.25 633.67 T
+(16) 241 633.67 T
+(im_self) 76.5 620.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 112.75 620.67 T
+(15) 241 620.67 T
+(imaginary literal) 76.5 607.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 154 607.67 T
+(8) 246.5 607.67 T
+(immutable) 76.5 594.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 129.25 594.67 T
+(13) 241 594.67 T
+(import) 76.5 581.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 110 581.67 T
+(6) 195.5 581.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 201 581.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(15) 207 581.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 218 581.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(23) 224 581.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 581.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 241 581.67 T
+(ImportError) 76.5 568.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 134.75 568.67 T
+(43) 241 568.67 T
+(in) 76.5 555.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 90.75 555.67 T
+(35) 224 555.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 555.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 241 555.67 T
+(INDENT token) 76.5 542.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 148.5 542.67 T
+(4) 246.5 542.67 T
+(Indentation) 76.5 529.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 132 529.67 T
+(4) 246.5 529.67 T
+(indentation) 76.5 516.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 129.25 516.67 T
+(4) 246.5 516.67 T
+(indentation errors) 76.5 503.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 159.5 503.67 T
+(5) 246.5 503.67 T
+(index operation) 76.5 490.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 490.67 T
+(13) 241 490.67 T
+(IndexError) 76.5 477.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 129.25 477.67 T
+(40) 241 477.67 T
+(inheritance) 76.5 464.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 129.25 464.67 T
+(49) 241 464.67 T
+(initialization) 76.5 451.67 T
+(module) 94.5 438.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 132 438.67 T
+(43) 241 438.67 T
+(input) 76.5 425.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 104.5 425.67 T
+(52) 241 425.67 T
+(instance) 76.5 412.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 118.25 412.67 T
+(15) 207 412.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 218 412.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 224 412.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 412.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(32) 241 412.67 T
+(call) 94.5 399.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 115.5 399.67 T
+(20) 241 399.67 T
+(class) 94.5 386.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 121 386.67 T
+(16) 241 386.67 T
+(integer) 76.5 373.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 112.75 373.67 T
+(8) 212.5 373.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 218 373.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(12) 224 373.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 373.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 241 373.67 T
+(long) 94.5 360.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 118.25 360.67 T
+(8) 246.5 360.67 T
+(integer literal) 76.5 347.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 140.25 347.67 T
+(8) 246.5 347.67 T
+(interactive mode) 76.5 334.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 154 334.67 T
+(51) 241 334.67 T
+(internal type) 76.5 321.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 137.5 321.67 T
+(16) 241 321.67 T
+(interpreter) 76.5 308.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 126.5 308.67 T
+(51) 241 308.67 T
+(invertion) 76.5 295.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 121 295.67 T
+(32) 241 295.67 T
+(is) 76.5 282.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 88 282.67 T
+(11) 224 282.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 282.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(35) 241 282.67 T
+(is not) 76.5 269.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 104.5 269.67 T
+(35) 241 269.67 T
+(item) 76.5 256.67 T
+(selection) 94.5 243.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 137.5 243.67 T
+(13) 241 243.67 T
+(string) 94.5 230.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 123.75 230.67 T
+(30) 241 230.67 T
+0 12 Q
+(K) 76.5 209 T
+1 11 Q
+(key) 76.5 195.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . . .) 96.25 195.67 T
+(28) 241 195.67 T
+(key/datum pair) 76.5 182.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 182.67 T
+(28) 241 182.67 T
+(keyword) 76.5 169.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 118.25 169.67 T
+(5) 246.5 169.67 T
+0 12 Q
+(L) 76.5 148 T
+1 11 Q
+(Lambda) 76.5 134.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 118.25 134.67 T
+(35) 241 134.67 T
+(leading whitespace) 76.5 121.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 165 121.67 T
+(4) 246.5 121.67 T
+(len) 76.5 108.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . . .) 93.5 108.67 T
+(13) 241 108.67 T
+(lexical analysis) 76.5 95.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 148.5 95.67 T
+(3) 246.5 95.67 T
+(lexical analyzer) 76.5 82.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 151.25 82.67 T
+(5) 246.5 82.67 T
+(lexical definitions) 76.5 69.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 159.5 69.67 T
+(1) 246.5 69.67 T
+(line) 306 712.67 T
+(blank) 324 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 352 699.67 T
+(4) 476 699.67 T
+(continuation) 324 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 382.25 686.67 T
+(3) 476 686.67 T
+(joining) 324 673.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 360.25 673.67 T
+(3) 476 673.67 T
+(physical) 324 660.67 T
+(split across) 342 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 396 647.67 T
+(3) 476 647.67 T
+(line joining) 306 634.67 T
+(implicit) 324 621.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 363 621.67 T
+(4) 476 621.67 T
+(line structure) 306 608.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 368.5 608.67 T
+(3) 476 608.67 T
+(lines) 306 595.67 T
+(logical) 324 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 357.5 582.67 T
+(3) 476 582.67 T
+(physical) 324 569.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 365.75 569.67 T
+(3) 476 569.67 T
+(list) 306 556.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . .) 324.5 556.67 T
+(13) 402.5 556.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 413.5 556.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(28) 419.5 556.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 430.5 556.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 436.5 556.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 556.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 453.5 556.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 556.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 470.5 556.67 T
+(empty) 324 543.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 354.75 543.67 T
+(28) 470.5 543.67 T
+(expression) 324 530.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . .) 376.75 530.67 T
+(36) 453.5 530.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 530.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(39) 470.5 530.67 T
+(target) 324 517.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 354.75 517.67 T
+(40) 470.5 517.67 T
+(deletion) 342 504.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 504.67 T
+(41) 470.5 504.67 T
+(Literal) 306 491.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 341 491.67 T
+(6) 476 491.67 T
+(literal) 306 478.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 335.5 478.67 T
+(27) 470.5 478.67 T
+(locals) 306 465.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 335.5 465.67 T
+(24) 453.5 465.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 465.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(44) 470.5 465.67 T
+(logical line) 306 452.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 360.25 452.67 T
+(3) 476 452.67 T
+(long integer) 306 439.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 363 439.67 T
+(12) 453.5 439.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 439.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 470.5 439.67 T
+(long integer literal) 306 426.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 390.5 426.67 T
+(8) 476 426.67 T
+(loop) 306 413.67 T
+(over mutable sequence) 324 400.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . .) 429 400.67 T
+(46) 470.5 400.67 T
+0 12 Q
+(M) 306 379 T
+1 11 Q
+(makefile) 306 365.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 349.25 365.67 T
+(16) 470.5 365.67 T
+(mapping) 306 352.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . .) 349.25 352.67 T
+(13) 419.5 352.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 430.5 352.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 436.5 352.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 352.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 453.5 352.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 352.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 470.5 352.67 T
+(method) 306 339.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 343.75 339.67 T
+(32) 470.5 339.67 T
+(bound) 324 326.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 354.75 326.67 T
+(14) 470.5 326.67 T
+(built-in) 324 313.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 360.25 313.67 T
+(15) 470.5 313.67 T
+(unbound) 324 300.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 365.75 300.67 T
+(14) 470.5 300.67 T
+(user-defined) 324 287.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 287.67 T
+(14) 470.5 287.67 T
+(creation) 342 274.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 274.67 T
+(14) 470.5 274.67 T
+(method object) 306 261.67 T
+(__name__) 324 248.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 374 248.67 T
+(14) 470.5 248.67 T
+(im_class) 324 235.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 365.75 235.67 T
+(14) 470.5 235.67 T
+(im_func) 324 222.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 365.75 222.67 T
+(14) 470.5 222.67 T
+(im_func.__doc__) 324 209.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . .) 407 209.67 T
+(14) 470.5 209.67 T
+(im_self) 324 196.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 360.25 196.67 T
+(14) 470.5 196.67 T
+(minus) 306 183.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 338.25 183.67 T
+(32) 470.5 183.67 T
+(module) 306 170.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 343.75 170.67 T
+(15) 436.5 170.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 170.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 453.5 170.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 170.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 470.5 170.67 T
+(built-in) 324 157.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 360.25 157.67 T
+(43) 470.5 157.67 T
+(extension) 324 144.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 371.25 144.67 T
+(12) 470.5 144.67 T
+(importing) 324 131.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 371.25 131.67 T
+(43) 470.5 131.67 T
+(user-defined) 324 118.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 118.67 T
+(43) 470.5 118.67 T
+(modulo) 306 105.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 343.75 105.67 T
+(33) 470.5 105.67 T
+(multiplication) 306 92.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 371.25 92.67 T
+(33) 470.5 92.67 T
+(mutable) 306 79.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 346.5 79.67 T
+(14) 436.5 79.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 447.5 79.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(39) 453.5 79.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 464.5 79.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 470.5 79.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "56" 62
+%%Page: "57" 63
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+0 X
+0 0 0 1 0 0 0 K
+4.8 (I) 288 748 S
+0 9.6 Q
+4.8 (NDEX) 296.13 748 S
+0 0 0 1 0 0 0 K
+1 10 Q
+(57) 525.5 32.83 T
+0 0 0 1 0 0 0 K
+315 720 315 63 2 L
+0.5 H
+2 Z
+N
+85.5 720 85.5 63 2 L
+N
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(mutable sequence) 94.5 712.67 T
+(loop over) 112.5 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 159.5 699.67 T
+(46) 259 699.67 T
+0 12 Q
+(N) 94.5 678 T
+1 11 Q
+(name) 94.5 664.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 123.75 664.67 T
+(5) 247.5 664.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 664.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 259 664.67 T
+(binding) 112.5 651.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 151.25 651.67 T
+(23) 242 651.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 651.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(39) 259 651.67 T
+(class) 112.5 638.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 638.67 T
+(49) 259 638.67 T
+(function) 112.5 625.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 625.67 T
+(48) 259 625.67 T
+(global) 112.5 612.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 143 612.67 T
+(27) 259 612.67 T
+(mangling) 112.5 599.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 159.5 599.67 T
+(6) 264.5 599.67 T
+(module) 112.5 586.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 148.5 586.67 T
+(43) 259 586.67 T
+(rebinding) 112.5 573.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 159.5 573.67 T
+(23) 242 573.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 573.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(39) 259 573.67 T
+(unbinding) 112.5 560.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 162.25 560.67 T
+(23) 242 560.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 560.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(41) 259 560.67 T
+(name space) 94.5 547.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 151.25 547.67 T
+(23) 259 547.67 T
+(global) 112.5 534.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 143 534.67 T
+(14) 242 534.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 534.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(23) 259 534.67 T
+(local) 112.5 521.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 521.67 T
+(23) 259 521.67 T
+(module) 112.5 508.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 148.5 508.67 T
+(15) 259 508.67 T
+(NameError) 94.5 495.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 495.67 T
+(24) 242 495.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 495.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 259 495.67 T
+(negation) 94.5 482.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 482.67 T
+(32) 259 482.67 T
+(NEWLINE token) 94.5 469.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . .) 176 469.67 T
+(3) 236 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 241.5 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(4) 247.5 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(45) 259 469.67 T
+(None) 94.5 456.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 123.75 456.67 T
+(12) 242 456.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 456.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(39) 259 456.67 T
+(not) 94.5 443.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . . .) 112.75 443.67 T
+(35) 259 443.67 T
+(not in) 94.5 430.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 123.75 430.67 T
+(35) 259 430.67 T
+(notation) 94.5 417.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 134.75 417.67 T
+(1) 264.5 417.67 T
+(null operation) 94.5 404.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 159.5 404.67 T
+(41) 259 404.67 T
+(number) 94.5 391.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 132 391.67 T
+(8) 230.5 391.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 236 391.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(12) 242 391.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 391.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 259 391.67 T
+(numbers) 94.5 378.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 137.5 378.67 T
+(16) 259 378.67 T
+(numeric) 94.5 365.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 365.67 T
+(12) 259 365.67 T
+(numeric arithmetic) 94.5 352.67 T
+(mixed mode) 112.5 339.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 170.5 339.67 T
+(22) 259 339.67 T
+(numeric literal) 94.5 326.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 162.25 326.67 T
+(8) 264.5 326.67 T
+0 12 Q
+(O) 94.5 305 T
+1 11 Q
+(object) 94.5 291.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . .) 126.5 291.67 T
+(11) 259 291.67 T
+(address in memory) 112.5 278.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . .) 200.75 278.67 T
+(11) 259 278.67 T
+(container) 112.5 265.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 156.75 265.67 T
+(11) 259 265.67 T
+(identity) 112.5 252.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 151.25 252.67 T
+(11) 259 252.67 T
+(immutable) 112.5 239.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 165 239.67 T
+(11) 259 239.67 T
+(mutable) 112.5 226.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 151.25 226.67 T
+(11) 259 226.67 T
+(reference to external resource) 112.5 213.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. .) 247.5 213.67 T
+(11) 259 213.67 T
+(type) 112.5 200.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 200.67 T
+(11) 259 200.67 T
+(unreachable) 112.5 187.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 170.5 187.67 T
+(11) 259 187.67 T
+(value) 112.5 174.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 140.25 174.67 T
+(11) 259 174.67 T
+(object closure) 94.5 161.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 159.5 161.67 T
+(14) 259 161.67 T
+(octal literal) 94.5 148.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 148.5 148.67 T
+(8) 264.5 148.67 T
+(open) 94.5 135.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 121 135.67 T
+(16) 259 135.67 T
+(operation) 94.5 122.67 T
+(arithmetic) 112.5 109.67 T
+(binary) 130.5 96.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 162.25 96.67 T
+(32) 259 96.67 T
+(unary) 130.5 83.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 159.5 83.67 T
+(32) 259 83.67 T
+(bit-wise) 112.5 70.67 T
+(binary) 360 712.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 393.25 712.67 T
+(33) 488.5 712.67 T
+(unary) 360 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 390.5 699.67 T
+(32) 488.5 699.67 T
+(boolean) 342 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 686.67 T
+(35) 488.5 686.67 T
+(null) 342 673.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 363 673.67 T
+(41) 488.5 673.67 T
+(shifting) 342 660.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 379.5 660.67 T
+(33) 488.5 660.67 T
+(operator) 324 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 365.75 647.67 T
+(9) 494 647.67 T
+(optimization) 324 634.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 385 634.67 T
+(15) 488.5 634.67 T
+(or) 324 621.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . . . .) 338.25 621.67 T
+(35) 488.5 621.67 T
+(bit-wise) 342 608.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 608.67 T
+(34) 488.5 608.67 T
+(exclusive) 342 595.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 387.75 595.67 T
+(34) 488.5 595.67 T
+(inclusive) 342 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 385 582.67 T
+(34) 488.5 582.67 T
+(ord) 324 569.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . . .) 343.75 569.67 T
+(13) 488.5 569.67 T
+(output) 324 556.67 T
+(standard) 342 543.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 385 543.67 T
+(39) 471.5 543.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 543.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(41) 488.5 543.67 T
+(OverflowError) 324 530.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 393.25 530.67 T
+(12) 488.5 530.67 T
+0 12 Q
+(P) 324 509 T
+1 11 Q
+(parameter) 324 495.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 371.25 495.67 T
+(48) 488.5 495.67 T
+(parameter list) 324 482.67 T
+(variable length) 342 469.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . .) 412.5 469.67 T
+(48) 488.5 469.67 T
+(parenthesized form) 324 456.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . .) 412.5 456.67 T
+(28) 488.5 456.67 T
+(parser) 324 443.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . .) 354.75 443.67 T
+(3) 482.5 443.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 488 443.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(5) 494 443.67 T
+(Pascal) 324 430.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . .) 357.5 430.67 T
+(46) 488.5 430.67 T
+(pass) 324 417.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 346.5 417.67 T
+(41) 488.5 417.67 T
+(path) 324 404.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 346.5 404.67 T
+(43) 488.5 404.67 T
+(plain integer) 324 391.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 385 391.67 T
+(12) 471.5 391.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 391.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 488.5 391.67 T
+(plain integer literal) 324 378.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 412.5 378.67 T
+(8) 494 378.67 T
+(plus) 324 365.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 346.5 365.67 T
+(32) 488.5 365.67 T
+(popen) 324 352.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 354.75 352.67 T
+(16) 488.5 352.67 T
+(pow) 324 339.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 346.5 339.67 T
+(32) 488.5 339.67 T
+(power operator) 324 326.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 396 326.67 T
+(32) 488.5 326.67 T
+(primary) 324 313.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 363 313.67 T
+(29) 488.5 313.67 T
+(print) 324 300.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 349.25 300.67 T
+(19) 471.5 300.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 300.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(41) 488.5 300.67 T
+(program) 324 287.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 365.75 287.67 T
+(51) 488.5 287.67 T
+(PYTHONPATH) 324 274.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 401.5 274.67 T
+(43) 488.5 274.67 T
+0 12 Q
+(Q) 324 253 T
+1 11 Q
+(quotes) 324 239.67 T
+(backward) 342 226.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 390.5 226.67 T
+(18) 471.5 226.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 226.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 488.5 226.67 T
+(double) 342 213.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 376.75 213.67 T
+(6) 494 213.67 T
+(reverse) 342 200.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 379.5 200.67 T
+(18) 471.5 200.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 200.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 488.5 200.67 T
+(single) 342 187.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 374 187.67 T
+(6) 494 187.67 T
+0 12 Q
+(R) 324 166 T
+1 11 Q
+(raise) 324 152.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . .) 349.25 152.67 T
+(42) 488.5 152.67 T
+(raised an exception) 324 139.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . .) 412.5 139.67 T
+(25) 488.5 139.67 T
+(range) 324 126.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 352 126.67 T
+(46) 488.5 126.67 T
+(raw_input) 324 113.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 374 113.67 T
+(52) 488.5 113.67 T
+(readline) 324 100.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 363 100.67 T
+(52) 488.5 100.67 T
+(recursive) 324 87.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 368.5 87.67 T
+(29) 488.5 87.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "57" 63
+%%Page: "58" 64
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 12 Q
+0 X
+0 0 0 1 0 0 0 K
+4.8 (I) 270 748 S
+0 9.6 Q
+4.8 (NDEX) 278.13 748 S
+0 0 0 1 0 0 0 K
+1 10 Q
+(58) 76.5 32.83 T
+0 0 0 1 0 0 0 K
+297 720 297 63 2 L
+0.5 H
+2 Z
+N
+67.5 720 67.5 63 2 L
+N
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(reference) 76.5 712.67 T
+(attribute) 94.5 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 134.75 699.67 T
+(29) 241 699.67 T
+(circular) 94.5 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 132 686.67 T
+(11) 241 686.67 T
+(count) 94.5 673.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 123.75 673.67 T
+(18) 241 673.67 T
+(counting) 94.5 660.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 137.5 660.67 T
+(11) 241 660.67 T
+(remainder) 76.5 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 126.5 647.67 T
+(33) 241 647.67 T
+(repr) 76.5 634.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 99 634.67 T
+(18) 207 634.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 218 634.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 224 634.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 634.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(39) 241 634.67 T
+(representation) 76.5 621.67 T
+(integer) 94.5 608.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 129.25 608.67 T
+(12) 241 608.67 T
+(reserved word) 76.5 595.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 143 595.67 T
+(5) 246.5 595.67 T
+(restricted execution mode) 76.5 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . .) 195.25 582.67 T
+(24) 241 582.67 T
+(return) 76.5 569.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 107.25 569.67 T
+(42) 224 569.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 569.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(47) 241 569.67 T
+(RuntimeError) 76.5 556.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 143 556.67 T
+(42) 241 556.67 T
+0 12 Q
+(S) 76.5 535 T
+1 11 Q
+(scope) 76.5 521.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 107.25 521.67 T
+(24) 241 521.67 T
+(script) 76.5 508.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 104.5 508.67 T
+(23) 241 508.67 T
+(search path) 76.5 495.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 132 495.67 T
+(43) 241 495.67 T
+(semicolon) 76.5 482.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 126.5 482.67 T
+(45) 241 482.67 T
+(sequence) 76.5 469.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . .) 121 469.67 T
+(13) 139 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 150 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(16) 156 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 167 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 173 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 184 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 190 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 201 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(35) 207 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 218 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 224 469.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 469.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 241 469.67 T
+(immutable) 94.5 456.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 145.75 456.67 T
+(13) 241 456.67 T
+(mutable) 94.5 443.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 134.75 443.67 T
+(13) 241 443.67 T
+(sign) 76.5 430.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . . .) 99 430.67 T
+(9) 246.5 430.67 T
+(slice) 76.5 417.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 101.75 417.67 T
+(20) 207 417.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 218 417.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 224 417.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 417.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 241 417.67 T
+(boundary) 94.5 404.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . .) 140.25 404.67 T
+(30) 224 404.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 404.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(41) 241 404.67 T
+(extended) 94.5 391.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 137.5 391.67 T
+(30) 241 391.67 T
+(simple) 94.5 378.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 129.25 378.67 T
+(30) 241 378.67 T
+(Slice objects) 76.5 365.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 137.5 365.67 T
+(17) 241 365.67 T
+(slicing) 76.5 352.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 110 352.67 T
+(13) 224 352.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 352.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 241 352.67 T
+(space) 76.5 339.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 104.5 339.67 T
+(4) 246.5 339.67 T
+(space count) 76.5 326.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 132 326.67 T
+(4) 246.5 326.67 T
+(square bracket) 76.5 313.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 145.75 313.67 T
+(4) 246.5 313.67 T
+(stack) 76.5 300.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 104.5 300.67 T
+(4) 246.5 300.67 T
+(execution) 94.5 287.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 143 287.67 T
+(17) 241 287.67 T
+(stack frame) 76.5 274.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 132 274.67 T
+(17) 241 274.67 T
+(standard inpu) 76.5 261.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 140.25 261.67 T
+(51) 241 261.67 T
+(standard output) 76.5 248.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 248.67 T
+(41) 241 248.67 T
+(statement) 76.5 235.67 T
+(assignment) 94.5 222.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 222.67 T
+(13) 241 222.67 T
+(compound) 94.5 209.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 145.75 209.67 T
+(45) 241 209.67 T
+(expression) 94.5 196.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 145.75 196.67 T
+(39) 241 196.67 T
+(loop) 94.5 183.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 118.25 183.67 T
+(42) 207 183.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 218 183.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 224 183.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 183.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 241 183.67 T
+(simple) 94.5 170.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 129.25 170.67 T
+(39) 241 170.67 T
+(statement grouping) 76.5 157.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 165 157.67 T
+(4) 246.5 157.67 T
+(statements) 76.5 144.67 T
+(assignment) 94.5 131.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 148.5 131.67 T
+(39) 241 131.67 T
+(stderr) 76.5 118.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 107.25 118.67 T
+(16) 241 118.67 T
+(stdin) 76.5 105.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . .) 101.75 105.67 T
+(16) 241 105.67 T
+(stdio) 76.5 92.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . . .) 101.75 92.67 T
+(16) 241 92.67 T
+(stdout) 76.5 79.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 107.25 79.67 T
+(16) 224 79.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 79.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(42) 241 79.67 T
+(str) 76.5 66.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . . . .) 90.75 66.67 T
+(19) 224 66.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 235 66.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 241 66.67 T
+(string) 306 712.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 335.5 712.67 T
+(13) 419.5 712.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 430.5 712.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 436.5 712.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 447.5 712.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 453.5 712.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 712.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 470.5 712.67 T
+(triple-quoted) 324 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 385 699.67 T
+(4) 476 699.67 T
+(string literal) 306 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . .) 363 686.67 T
+(6) 476 686.67 T
+(concatenation) 324 673.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 390.5 673.67 T
+(7) 476 673.67 T
+(subscription) 306 660.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . .) 363 660.67 T
+(13) 453.5 660.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 660.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 470.5 660.67 T
+(subtraction) 306 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 360.25 647.67 T
+(33) 470.5 647.67 T
+(suite) 306 634.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 330 634.67 T
+(45) 470.5 634.67 T
+(suppression) 306 621.67 T
+(newline) 324 608.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 363 608.67 T
+(42) 470.5 608.67 T
+(syntax) 306 595.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 338.25 595.67 T
+(1) 459 595.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 595.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(27) 470.5 595.67 T
+(SyntaxError) 306 582.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 363 582.67 T
+(43) 470.5 582.67 T
+(sys) 306 569.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 324.5 569.67 T
+(42) 453.5 569.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 569.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(51) 470.5 569.67 T
+(exc_traceback) 324 556.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . .) 390.5 556.67 T
+(17) 453.5 556.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 464.5 556.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(47) 470.5 556.67 T
+(exc_type) 324 543.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 368.5 543.67 T
+(47) 470.5 543.67 T
+(exc_value) 324 530.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 374 530.67 T
+(47) 470.5 530.67 T
+(last_traceback) 324 517.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 390.5 517.67 T
+(17) 470.5 517.67 T
+(sys.exc_traceback) 306 504.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 390.5 504.67 T
+(18) 470.5 504.67 T
+(sys.last_traceback) 306 491.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 390.5 491.67 T
+(18) 470.5 491.67 T
+(sys.modules) 306 478.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 365.75 478.67 T
+(43) 470.5 478.67 T
+(sys.path) 306 465.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . .) 346.5 465.67 T
+(43) 470.5 465.67 T
+(sys.stderr) 306 452.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 352 452.67 T
+(16) 470.5 452.67 T
+(sys.stdin) 306 439.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 349.25 439.67 T
+(16) 470.5 439.67 T
+(sys.stdout) 306 426.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 354.75 426.67 T
+(16) 470.5 426.67 T
+0 12 Q
+(T) 306 405 T
+1 11 Q
+(tab) 306 391.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . . . .) 324.5 391.67 T
+(4) 476 391.67 T
+(target) 306 378.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . .) 335.5 378.67 T
+(40) 470.5 378.67 T
+(deletion) 324 365.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 363 365.67 T
+(41) 470.5 365.67 T
+(loop control) 324 352.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 352.67 T
+(42) 470.5 352.67 T
+(test) 306 339.67 T
+(identity) 324 326.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 363 326.67 T
+(35) 470.5 326.67 T
+(membership) 324 313.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . .) 382.25 313.67 T
+(35) 470.5 313.67 T
+(token) 306 300.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . . . . . .) 335.5 300.67 T
+(3) 476 300.67 T
+(delimiter) 324 287.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 368.5 287.67 T
+(5) 476 287.67 T
+(identifier) 324 274.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 368.5 274.67 T
+(5) 476 274.67 T
+(keyword) 324 261.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 365.75 261.67 T
+(5) 476 261.67 T
+(literal) 324 248.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 354.75 248.67 T
+(5) 476 248.67 T
+(operator) 324 235.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 365.75 235.67 T
+(5) 476 235.67 T
+(tracback object) 306 222.67 T
+(tb_frame) 324 209.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 368.5 209.67 T
+(17) 470.5 209.67 T
+(tb_lasti) 324 196.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 360.25 196.67 T
+(17) 470.5 196.67 T
+(tb_lineno) 324 183.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 371.25 183.67 T
+(17) 470.5 183.67 T
+(tb_next) 324 170.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 360.25 170.67 T
+(17) 470.5 170.67 T
+(trace) 306 157.67 T
+(stack) 324 144.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 352 144.67 T
+(17) 470.5 144.67 T
+(traceback) 306 131.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 352 131.67 T
+(42) 470.5 131.67 T
+(traceback object) 306 118.67 T
+(exc_traceback) 324 105.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 390.5 105.67 T
+(17) 470.5 105.67 T
+(last_traceback) 324 92.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 390.5 92.67 T
+(17) 470.5 92.67 T
+(transformation) 306 79.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 374 79.67 T
+(15) 470.5 79.67 T
+(triple-quoted strings) 306 66.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 398.75 66.67 T
+(6) 476 66.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "58" 64
+%%Page: "59" 65
+612 792 0 FMBEGINPAGE
+[0 0 0 1 0 0 0]
+[ 0 1 1 0 1 0 0]
+[ 1 0 1 0 0 1 0]
+[ 1 1 0 0 0 0 1]
+[ 1 0 0 0 0 1 1]
+[ 0 1 0 0 1 0 1]
+[ 0 0 1 0 1 1 0]
+ 7 FrameSetSepColors
+FrameNoSep
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+0 12 Q
+0 X
+0 0 0 1 0 0 0 K
+4.8 (I) 288 748 S
+0 9.6 Q
+4.8 (NDEX) 296.13 748 S
+0 0 0 1 0 0 0 K
+1 10 Q
+(59) 525.5 32.83 T
+0 0 0 1 0 0 0 K
+315 720 315 63 2 L
+0.5 H
+2 Z
+N
+85.5 720 85.5 63 2 L
+N
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+1 11 Q
+(try) 94.5 712.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 110 712.67 T
+(11) 208 712.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 219 712.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(17) 225 712.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 236 712.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(42) 242 712.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 712.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(47) 259 712.67 T
+(finally) 112.5 699.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 145.75 699.67 T
+(43) 259 699.67 T
+(tuple) 94.5 686.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . .) 121 686.67 T
+(13) 191 686.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 202 686.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(29) 208 686.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 219 686.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(30) 225 686.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 236 686.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(36) 242 686.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 686.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 259 686.67 T
+(empty) 112.5 673.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . .) 143 673.67 T
+(13) 225 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 236 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(28) 242 673.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 673.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(36) 259 673.67 T
+(singleton) 112.5 660.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . .) 156.75 660.67 T
+(13) 259 660.67 T
+(type) 94.5 647.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 118.25 647.67 T
+(11) 242 647.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 253 647.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(12) 259 647.67 T
+(data) 112.5 634.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . . .) 134.75 634.67 T
+(12) 259 634.67 T
+(immutable) 130.5 621.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . .) 181.5 621.67 T
+(28) 259 621.67 T
+(hierarchy) 112.5 608.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . .) 159.5 608.67 T
+(12) 259 608.67 T
+(TypeError) 94.5 595.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . .) 145.75 595.67 T
+(29) 208 595.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 219 595.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(31) 225 595.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 236 595.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(32) 242 595.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 595.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(40) 259 595.67 T
+0 12 Q
+(U) 94.5 574 T
+1 11 Q
+(UNIX) 94.5 560.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . . . .) 126.5 560.67 T
+(4) 247.5 560.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 253 560.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(51) 259 560.67 T
+(unrecognized escape sequences) 94.5 547.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . .) 236.5 547.67 T
+(7) 264.5 547.67 T
+(user-defined) 94.5 534.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 154 534.67 T
+(14) 259 534.67 T
+(user-defined function) 94.5 521.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . .) 192.5 521.67 T
+(32) 259 521.67 T
+0 12 Q
+(V) 324 712 T
+1 11 Q
+(value) 324 698.67 T
+(parameter) 342 685.67 T
+(default) 360 672.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . .) 396 672.67 T
+(48) 488.5 672.67 T
+(writing) 342 659.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 379.5 659.67 T
+(39) 488.5 659.67 T
+(ValueError) 324 646.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . .) 376.75 646.67 T
+(33) 488.5 646.67 T
+(values) 324 633.67 T
+(writing) 342 620.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . . .) 379.5 620.67 T
+(41) 488.5 620.67 T
+(Von Neumann) 324 607.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . .) 393.25 607.67 T
+(11) 488.5 607.67 T
+0 12 Q
+(W) 324 586 T
+1 11 Q
+(while) 324 572.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+(. . . . . . . . . . . . . . . . . . .) 352 572.67 T
+(42) 454.5 572.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(\320) 465.5 572.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(43) 471.5 572.67 T
+0 0 0 1 0 0 0 K
+1 12 Q
+(,) 482.5 572.67 T
+0 0 0 1 0 0 0 K
+1 11 Q
+(46) 488.5 572.67 T
+(whitespace) 324 559.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . . . .) 376.75 559.67 T
+(4) 494 559.67 T
+0 12 Q
+(X) 324 538 T
+1 11 Q
+(xor) 324 524.67 T
+(bit-wise) 342 511.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . . . . . . .) 382.25 511.67 T
+(34) 488.5 511.67 T
+0 12 Q
+(Z) 324 490 T
+1 11 Q
+(ZeroDivisionError) 324 476.67 T
+0 0 0 1 0 0 0 K
+0 0 0 1 0 0 0 K
+( . . . . . . . . . . . . . .) 409.75 476.67 T
+(33) 488.5 476.67 T
+0 0 0 1 0 0 0 K
+FMENDPAGE
+%%EndPage: "59" 65
+%%Trailer
+%%BoundingBox: 0 0 612 792
+%%PageOrder: Ascend
+%%Pages: 65
+%%DocumentFonts: Helvetica-Bold
+%%+ Times-Roman
+%%+ Courier
+%%+ Times-Italic
+%%+ Times-Bold
+%%+ Helvetica
+%%+ Courier-Oblique
+%%+ Courier-Bold
+%%EOF
diff --git a/Doc/ref/ref.tex b/Doc/ref/ref.tex
deleted file mode 100644
index e63fa7c..0000000
--- a/Doc/ref/ref.tex
+++ /dev/null
@@ -1,68 +0,0 @@
-\documentstyle[twoside,11pt,myformat]{report}
-
-\title{Python Reference Manual}
-
-\input{boilerplate}
-
-% Tell \index to actually write the .idx file
-\makeindex
-
-\begin{document}
-
-\pagenumbering{roman}
-
-\maketitle
-
-\input{copyright}
-
-\begin{abstract}
-
-\noindent
-Python is a simple, yet powerful, interpreted programming language
-that bridges the gap between C and shell programming, and is thus
-ideally suited for ``throw-away programming'' and rapid prototyping.
-Its syntax is put together from constructs borrowed from a variety of
-other languages; most prominent are influences from ABC, C, Modula-3
-and Icon.
-
-The Python interpreter is easily extended with new functions and data
-types implemented in C.  Python is also suitable as an extension
-language for highly customizable C applications such as editors or
-window managers.
-
-Python is available for various operating systems, amongst which
-several flavors of {\UNIX} (including Linux), the Apple Macintosh O.S.,
-MS-DOS, MS-Windows 3.1, Windows NT, and OS/2.
-
-This reference manual describes the syntax and ``core semantics'' of
-the language.  It is terse, but attempts to be exact and complete.
-The semantics of non-essential built-in object types and of the
-built-in functions and modules are described in the {\em Python
-Library Reference}.  For an informal introduction to the language, see
-the {\em Python Tutorial}.
-
-\end{abstract}
-
-\pagebreak
-
-{
-\parskip = 0mm
-\tableofcontents
-}
-
-\pagebreak
-
-\pagenumbering{arabic}
-
-\include{ref1}		% Introduction
-\include{ref2}		% Lexical analysis
-\include{ref3}		% Data model
-\include{ref4}		% Execution model
-\include{ref5}		% Expressions and conditions
-\include{ref6}		% Simple statements
-\include{ref7}		% Compound statements
-\include{ref8}		% Top-level components
-
-\input{ref.ind}
-
-\end{document}
diff --git a/Doc/ref/ref1.tex b/Doc/ref/ref1.tex
deleted file mode 100644
index 30bfcce..0000000
--- a/Doc/ref/ref1.tex
+++ /dev/null
@@ -1,81 +0,0 @@
-\chapter{Introduction}
-
-This reference manual describes the Python programming language.
-It is not intended as a tutorial.
-
-While I am trying to be as precise as possible, I chose to use English
-rather than formal specifications for everything except syntax and
-lexical analysis.  This should make the document more understandable
-to the average reader, but will leave room for ambiguities.
-Consequently, if you were coming from Mars and tried to re-implement
-Python from this document alone, you might have to guess things and in
-fact you would probably end up implementing quite a different language.
-On the other hand, if you are using
-Python and wonder what the precise rules about a particular area of
-the language are, you should definitely be able to find them here.
-
-It is dangerous to add too many implementation details to a language
-reference document --- the implementation may change, and other
-implementations of the same language may work differently.  On the
-other hand, there is currently only one Python implementation, and
-its particular quirks are sometimes worth being mentioned, especially
-where the implementation imposes additional limitations.  Therefore,
-you'll find short ``implementation notes'' sprinkled throughout the
-text.
-
-Every Python implementation comes with a number of built-in and
-standard modules.  These are not documented here, but in the separate
-{\em Python Library Reference} document.  A few built-in modules are
-mentioned when they interact in a significant way with the language
-definition.
-
-\section{Notation}
-
-The descriptions of lexical analysis and syntax use a modified BNF
-grammar notation.  This uses the following style of definition:
-\index{BNF}
-\index{grammar}
-\index{syntax}
-\index{notation}
-
-\begin{verbatim}
-name:           lc_letter (lc_letter | "_")*
-lc_letter:      "a"..."z"
-\end{verbatim}
-
-The first line says that a \verb@name@ is an \verb@lc_letter@ followed by
-a sequence of zero or more \verb@lc_letter@s and underscores.  An
-\verb@lc_letter@ in turn is any of the single characters `a' through `z'.
-(This rule is actually adhered to for the names defined in lexical and
-grammar rules in this document.)
-
-Each rule begins with a name (which is the name defined by the rule)
-and a colon.  A vertical bar (\verb@|@) is used to separate
-alternatives; it is the least binding operator in this notation.  A
-star (\verb@*@) means zero or more repetitions of the preceding item;
-likewise, a plus (\verb@+@) means one or more repetitions, and a
-phrase enclosed in square brackets (\verb@[ ]@) means zero or one
-occurrences (in other words, the enclosed phrase is optional).  The
-\verb@*@ and \verb@+@ operators bind as tightly as possible;
-parentheses are used for grouping.  Literal strings are enclosed in
-quotes.  White space is only meaningful to separate tokens.
-Rules are normally contained on a single line; rules with many
-alternatives may be formatted alternatively with each line after the
-first beginning with a vertical bar.
-
-In lexical definitions (as the example above), two more conventions
-are used: Two literal characters separated by three dots mean a choice
-of any single character in the given (inclusive) range of \ASCII{}
-characters.  A phrase between angular brackets (\verb@<...>@) gives an
-informal description of the symbol defined; e.g. this could be used
-to describe the notion of `control character' if needed.
-\index{lexical definitions}
-\index{ASCII}
-
-Even though the notation used is almost the same, there is a big
-difference between the meaning of lexical and syntactic definitions:
-a lexical definition operates on the individual characters of the
-input source, while a syntax definition operates on the stream of
-tokens generated by the lexical analysis.  All uses of BNF in the next
-chapter (``Lexical Analysis'') are lexical definitions; uses in
-subsequent chapters are syntactic definitions.
diff --git a/Doc/ref/ref2.tex b/Doc/ref/ref2.tex
deleted file mode 100644
index b093998..0000000
--- a/Doc/ref/ref2.tex
+++ /dev/null
@@ -1,372 +0,0 @@
-\chapter{Lexical analysis}
-
-A Python program is read by a {\em parser}.  Input to the parser is a
-stream of {\em tokens}, generated by the {\em lexical analyzer}.  This
-chapter describes how the lexical analyzer breaks a file into tokens.
-\index{lexical analysis}
-\index{parser}
-\index{token}
-
-\section{Line structure}
-
-A Python program is divided in a number of logical lines.  The end of
-a logical line is represented by the token NEWLINE.  Statements cannot
-cross logical line boundaries except where NEWLINE is allowed by the
-syntax (e.g. between statements in compound statements).
-\index{line structure}
-\index{logical line}
-\index{NEWLINE token}
-
-\subsection{Comments}
-
-A comment starts with a hash character (\verb@#@) that is not part of
-a string literal, and ends at the end of the physical line.  A comment
-always signifies the end of the logical line.  Comments are ignored by
-the syntax.
-\index{comment}
-\index{logical line}
-\index{physical line}
-\index{hash character}
-
-\subsection{Explicit line joining}
-
-Two or more physical lines may be joined into logical lines using
-backslash characters (\verb/\/), as follows: when a physical line ends
-in a backslash that is not part of a string literal or comment, it is
-joined with the following forming a single logical line, deleting the
-backslash and the following end-of-line character.  For example:
-\index{physical line}
-\index{line joining}
-\index{line continuation}
-\index{backslash character}
-%
-\begin{verbatim}
-if 1900 < year < 2100 and 1 <= month <= 12 \
-   and 1 <= day <= 31 and 0 <= hour < 24 \
-   and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
-        return 1
-\end{verbatim}
-
-A line ending in a backslash cannot carry a comment; a backslash does
-not continue a comment (but it does continue a string literal, see
-below).
-
-\subsection{Implicit line joining}
-
-Expressions in parentheses, square brackets or curly braces can be
-split over more than one physical line without using backslashes.
-For example:
-
-\begin{verbatim}
-month_names = ['Januari', 'Februari', 'Maart',      # These are the
-               'April',   'Mei',      'Juni',       # Dutch names
-               'Juli',    'Augustus', 'September',  # for the months
-               'Oktober', 'November', 'December']   # of the year
-\end{verbatim}
-
-Implicitly continued lines can carry comments.  The indentation of the
-continuation lines is not important.  Blank continuation lines are
-allowed.
-
-\subsection{Blank lines}
-
-A logical line that contains only spaces, tabs, and possibly a
-comment, is ignored (i.e., no NEWLINE token is generated), except that
-during interactive input of statements, an entirely blank logical line
-terminates a multi-line statement.
-\index{blank line}
-
-\subsection{Indentation}
-
-Leading whitespace (spaces and tabs) at the beginning of a logical
-line is used to compute the indentation level of the line, which in
-turn is used to determine the grouping of statements.
-\index{indentation}
-\index{whitespace}
-\index{leading whitespace}
-\index{space}
-\index{tab}
-\index{grouping}
-\index{statement grouping}
-
-First, tabs are replaced (from left to right) by one to eight spaces
-such that the total number of characters up to there is a multiple of
-eight (this is intended to be the same rule as used by {\UNIX}).  The
-total number of spaces preceding the first non-blank character then
-determines the line's indentation.  Indentation cannot be split over
-multiple physical lines using backslashes.
-
-The indentation levels of consecutive lines are used to generate
-INDENT and DEDENT tokens, using a stack, as follows.
-\index{INDENT token}
-\index{DEDENT token}
-
-Before the first line of the file is read, a single zero is pushed on
-the stack; this will never be popped off again.  The numbers pushed on
-the stack will always be strictly increasing from bottom to top.  At
-the beginning of each logical line, the line's indentation level is
-compared to the top of the stack.  If it is equal, nothing happens.
-If it is larger, it is pushed on the stack, and one INDENT token is
-generated.  If it is smaller, it {\em must} be one of the numbers
-occurring on the stack; all numbers on the stack that are larger are
-popped off, and for each number popped off a DEDENT token is
-generated.  At the end of the file, a DEDENT token is generated for
-each number remaining on the stack that is larger than zero.
-
-Here is an example of a correctly (though confusingly) indented piece
-of Python code:
-
-\begin{verbatim}
-def perm(l):
-        # Compute the list of all permutations of l
-
-    if len(l) <= 1:
-                  return [l]
-    r = []
-    for i in range(len(l)):
-             s = l[:i] + l[i+1:]
-             p = perm(s)
-             for x in p:
-              r.append(l[i:i+1] + x)
-    return r
-\end{verbatim}
-
-The following example shows various indentation errors:
-
-\begin{verbatim}
-    def perm(l):                        # error: first line indented
-    for i in range(len(l)):             # error: not indented
-        s = l[:i] + l[i+1:]
-            p = perm(l[:i] + l[i+1:])   # error: unexpected indent
-            for x in p:
-                    r.append(l[i:i+1] + x)
-                return r                # error: inconsistent dedent
-\end{verbatim}
-
-(Actually, the first three errors are detected by the parser; only the
-last error is found by the lexical analyzer --- the indentation of
-\verb@return r@ does not match a level popped off the stack.)
-
-\section{Other tokens}
-
-Besides NEWLINE, INDENT and DEDENT, the following categories of tokens
-exist: identifiers, keywords, literals, operators, and delimiters.
-Spaces and tabs are not tokens, but serve to delimit tokens.  Where
-ambiguity exists, a token comprises the longest possible string that
-forms a legal token, when read from left to right.
-
-\section{Identifiers}
-
-Identifiers (also referred to as names) are described by the following
-lexical definitions:
-\index{identifier}
-\index{name}
-
-\begin{verbatim}
-identifier:     (letter|"_") (letter|digit|"_")*
-letter:         lowercase | uppercase
-lowercase:      "a"..."z"
-uppercase:      "A"..."Z"
-digit:          "0"..."9"
-\end{verbatim}
-
-Identifiers are unlimited in length.  Case is significant.
-
-\subsection{Keywords}
-
-The following identifiers are used as reserved words, or {\em
-keywords} of the language, and cannot be used as ordinary
-identifiers.  They must be spelled exactly as written here:
-\index{keyword}
-\index{reserved word}
-
-\begin{verbatim}
-and        elif       global     not        try       
-break      else       if         or         while     
-class      except     import     pass      
-continue   finally    in         print     
-def        for        is         raise     
-del        from       lambda     return    
-\end{verbatim}
-
-% When adding keywords, pipe it through keywords.py for reformatting
-
-\section{Literals} \label{literals}
-
-Literals are notations for constant values of some built-in types.
-\index{literal}
-\index{constant}
-
-\subsection{String literals}
-
-String literals are described by the following lexical definitions:
-\index{string literal}
-
-\begin{verbatim}
-stringliteral:   shortstring | longstring
-shortstring:     "'" shortstringitem* "'" | '"' shortstringitem* '"'
-longstring:      "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
-shortstringitem: shortstringchar | escapeseq
-longstringitem:  longstringchar | escapeseq
-shortstringchar: <any ASCII character except "\" or newline or the quote>
-longstringchar:  <any ASCII character except "\">
-escapeseq:       "\" <any ASCII character>
-\end{verbatim}
-\index{ASCII}
-
-In ``long strings'' (strings surrounded by sets of three quotes),
-unescaped newlines and quotes are allowed (and are retained), except
-that three unescaped quotes in a row terminate the string.  (A
-``quote'' is the character used to open the string, i.e. either
-\verb/'/ or \verb/"/.)
-
-Escape sequences in strings are interpreted according to rules similar
-to those used by Standard C.  The recognized escape sequences are:
-\index{physical line}
-\index{escape sequence}
-\index{Standard C}
-\index{C}
-
-\begin{center}
-\begin{tabular}{|l|l|}
-\hline
-\verb/\/{\em newline}	& Ignored \\
-\verb/\\/	& Backslash (\verb/\/) \\
-\verb/\'/	& Single quote (\verb/'/) \\
-\verb/\"/	& Double quote (\verb/"/) \\
-\verb/\a/	& \ASCII{} Bell (BEL) \\
-\verb/\b/	& \ASCII{} Backspace (BS) \\
-%\verb/\E/	& \ASCII{} Escape (ESC) \\
-\verb/\f/	& \ASCII{} Formfeed (FF) \\
-\verb/\n/	& \ASCII{} Linefeed (LF) \\
-\verb/\r/	& \ASCII{} Carriage Return (CR) \\
-\verb/\t/	& \ASCII{} Horizontal Tab (TAB) \\
-\verb/\v/	& \ASCII{} Vertical Tab (VT) \\
-\verb/\/{\em ooo}	& \ASCII{} character with octal value {\em ooo} \\
-\verb/\x/{\em xx...}	& \ASCII{} character with hex value {\em xx...} \\
-\hline
-\end{tabular}
-\end{center}
-\index{ASCII}
-
-In strict compatibility with Standard C, up to three octal digits are
-accepted, but an unlimited number of hex digits is taken to be part of
-the hex escape (and then the lower 8 bits of the resulting hex number
-are used in all current implementations...).
-
-All unrecognized escape sequences are left in the string unchanged,
-i.e., {\em the backslash is left in the string.}  (This behavior is
-useful when debugging: if an escape sequence is mistyped, the
-resulting output is more easily recognized as broken.  It also helps a
-great deal for string literals used as regular expressions or
-otherwise passed to other modules that do their own escape handling.)
-\index{unrecognized escape sequence}
-
-\subsection{Numeric literals}
-
-There are three types of numeric literals: plain integers, long
-integers, and floating point numbers.
-\index{number}
-\index{numeric literal}
-\index{integer literal}
-\index{plain integer literal}
-\index{long integer literal}
-\index{floating point literal}
-\index{hexadecimal literal}
-\index{octal literal}
-\index{decimal literal}
-
-Integer and long integer literals are described by the following
-lexical definitions:
-
-\begin{verbatim}
-longinteger:    integer ("l"|"L")
-integer:        decimalinteger | octinteger | hexinteger
-decimalinteger: nonzerodigit digit* | "0"
-octinteger:     "0" octdigit+
-hexinteger:     "0" ("x"|"X") hexdigit+
-
-nonzerodigit:   "1"..."9"
-octdigit:       "0"..."7"
-hexdigit:        digit|"a"..."f"|"A"..."F"
-\end{verbatim}
-
-Although both lower case `l' and upper case `L' are allowed as suffix
-for long integers, it is strongly recommended to always use `L', since
-the letter `l' looks too much like the digit `1'.
-
-Plain integer decimal literals must be at most 2147483647 (i.e., the
-largest positive integer, using 32-bit arithmetic).  Plain octal and
-hexadecimal literals may be as large as 4294967295, but values larger
-than 2147483647 are converted to a negative value by subtracting
-4294967296.  There is no limit for long integer literals apart from
-what can be stored in available memory.
-
-Some examples of plain and long integer literals:
-
-\begin{verbatim}
-7     2147483647                        0177    0x80000000
-3L    79228162514264337593543950336L    0377L   0x100000000L
-\end{verbatim}
-
-Floating point literals are described by the following lexical
-definitions:
-
-\begin{verbatim}
-floatnumber:    pointfloat | exponentfloat
-pointfloat:     [intpart] fraction | intpart "."
-exponentfloat:  (intpart | pointfloat) exponent
-intpart:        digit+
-fraction:       "." digit+
-exponent:       ("e"|"E") ["+"|"-"] digit+
-\end{verbatim}
-
-The allowed range of floating point literals is
-implementation-dependent.
-
-Some examples of floating point literals:
-
-\begin{verbatim}
-3.14    10.    .001    1e100    3.14e-10
-\end{verbatim}
-
-Note that numeric literals do not include a sign; a phrase like
-\verb@-1@ is actually an expression composed of the operator
-\verb@-@ and the literal \verb@1@.
-
-\section{Operators}
-
-The following tokens are operators:
-\index{operators}
-
-\begin{verbatim}
-+       -       *       /       %
-<<      >>      &       |       ^       ~
-<       ==      >       <=      <>      !=      >=
-\end{verbatim}
-
-The comparison operators \verb@<>@ and \verb@!=@ are alternate
-spellings of the same operator.
-
-\section{Delimiters}
-
-The following tokens serve as delimiters or otherwise have a special
-meaning:
-\index{delimiters}
-
-\begin{verbatim}
-(       )       [       ]       {       }
-,       :       .       "       `       '
-=	;
-\end{verbatim}
-
-The following printing \ASCII{} characters are not used in Python.  Their
-occurrence outside string literals and comments is an unconditional
-error:
-\index{ASCII}
-
-\begin{verbatim}
-@       $       ?
-\end{verbatim}
-
-They may be used by future versions of the language though!
diff --git a/Doc/ref/ref3.tex b/Doc/ref/ref3.tex
deleted file mode 100644
index ca3525a..0000000
--- a/Doc/ref/ref3.tex
+++ /dev/null
@@ -1,885 +0,0 @@
-\chapter{Data model}
-
-\section{Objects, values and types}
-
-{\em Objects} are Python's abstraction for data.  All data in a Python
-program is represented by objects or by relations between objects.
-(In a sense, and in conformance to Von Neumann's model of a
-``stored program computer'', code is also represented by objects.)
-\index{object}
-\index{data}
-
-Every object has an identity, a type and a value.  An object's {\em
-identity} never changes once it has been created; you may think of it
-as the object's address in memory.  An object's {\em type} is also
-unchangeable.  It determines the operations that an object supports
-(e.g. ``does it have a length?'') and also defines the possible
-values for objects of that type.  The {\em value} of some objects can
-change.  Objects whose value can change are said to be {\em mutable};
-objects whose value is unchangeable once they are created are called
-{\em immutable}.  The type determines an object's (im)mutability.
-\index{identity of an object}
-\index{value of an object}
-\index{type of an object}
-\index{mutable object}
-\index{immutable object}
-
-Objects are never explicitly destroyed; however, when they become
-unreachable they may be garbage-collected.  An implementation is
-allowed to delay garbage collection or omit it altogether --- it is a
-matter of implementation quality how garbage collection is
-implemented, as long as no objects are collected that are still
-reachable.  (Implementation note: the current implementation uses a
-reference-counting scheme which collects most objects as soon as they
-become unreachable, but never collects garbage containing circular
-references.)
-\index{garbage collection}
-\index{reference counting}
-\index{unreachable object}
-
-Note that the use of the implementation's tracing or debugging
-facilities may keep objects alive that would normally be collectable.
-
-Some objects contain references to ``external'' resources such as open
-files or windows.  It is understood that these resources are freed
-when the object is garbage-collected, but since garbage collection is
-not guaranteed to happen, such objects also provide an explicit way to
-release the external resource, usually a \verb@close@ method.
-Programs are strongly recommended to always explicitly close such
-objects.
-
-Some objects contain references to other objects; these are called
-{\em containers}.  Examples of containers are tuples, lists and
-dictionaries.  The references are part of a container's value.  In
-most cases, when we talk about the value of a container, we imply the
-values, not the identities of the contained objects; however, when we
-talk about the (im)mutability of a container, only the identities of
-the immediately contained objects are implied.  (So, if an immutable
-container contains a reference to a mutable object, its value changes
-if that mutable object is changed.)
-\index{container}
-
-Types affect almost all aspects of objects' lives.  Even the meaning
-of object identity is affected in some sense: for immutable types,
-operations that compute new values may actually return a reference to
-any existing object with the same type and value, while for mutable
-objects this is not allowed.  E.g. after
-
-\begin{verbatim}
-a = 1; b = 1; c = []; d = []
-\end{verbatim}
-
-\verb@a@ and \verb@b@ may or may not refer to the same object with the
-value one, depending on the implementation, but \verb@c@ and \verb@d@
-are guaranteed to refer to two different, unique, newly created empty
-lists.
-
-\section{The standard type hierarchy} \label{types}
-
-Below is a list of the types that are built into Python.  Extension
-modules written in C can define additional types.  Future versions of
-Python may add types to the type hierarchy (e.g. rational or complex
-numbers, efficiently stored arrays of integers, etc.).
-\index{type}
-\indexii{data}{type}
-\indexii{type}{hierarchy}
-\indexii{extension}{module}
-\index{C}
-
-Some of the type descriptions below contain a paragraph listing
-`special attributes'.  These are attributes that provide access to the
-implementation and are not intended for general use.  Their definition
-may change in the future.  There are also some `generic' special
-attributes, not listed with the individual objects: \verb@__methods__@
-is a list of the method names of a built-in object, if it has any;
-\verb@__members__@ is a list of the data attribute names of a built-in
-object, if it has any.
-\index{attribute}
-\indexii{special}{attribute}
-\indexiii{generic}{special}{attribute}
-\ttindex{__methods__}
-\ttindex{__members__}
-
-\begin{description}
-
-\item[None]
-This type has a single value.  There is a single object with this value.
-This object is accessed through the built-in name \verb@None@.
-It is returned from functions that don't explicitly return an object.
-\ttindex{None}
-\obindex{None@{\tt None}}
-
-\item[Numbers]
-These are created by numeric literals and returned as results by
-arithmetic operators and arithmetic built-in functions.  Numeric
-objects are immutable; once created their value never changes.  Python
-numbers are of course strongly related to mathematical numbers, but
-subject to the limitations of numerical representation in computers.
-\obindex{number}
-\obindex{numeric}
-
-Python distinguishes between integers and floating point numbers:
-
-\begin{description}
-\item[Integers]
-These represent elements from the mathematical set of whole numbers.
-\obindex{integer}
-
-There are two types of integers:
-
-\begin{description}
-
-\item[Plain integers]
-These represent numbers in the range -2147483648 through 2147483647.
-(The range may be larger on machines with a larger natural word
-size, but not smaller.)
-When the result of an operation falls outside this range, the
-exception \verb@OverflowError@ is raised.
-For the purpose of shift and mask operations, integers are assumed to
-have a binary, 2's complement notation using 32 or more bits, and
-hiding no bits from the user (i.e., all 4294967296 different bit
-patterns correspond to different values).
-\obindex{plain integer}
-
-\item[Long integers]
-These represent numbers in an unlimited range, subject to available
-(virtual) memory only.  For the purpose of shift and mask operations,
-a binary representation is assumed, and negative numbers are
-represented in a variant of 2's complement which gives the illusion of
-an infinite string of sign bits extending to the left.
-\obindex{long integer}
-
-\end{description} % Integers
-
-The rules for integer representation are intended to give the most
-meaningful interpretation of shift and mask operations involving
-negative integers and the least surprises when switching between the
-plain and long integer domains.  For any operation except left shift,
-if it yields a result in the plain integer domain without causing
-overflow, it will yield the same result in the long integer domain or
-when using mixed operands.
-\indexii{integer}{representation}
-
-\item[Floating point numbers]
-These represent machine-level double precision floating point numbers.  
-You are at the mercy of the underlying machine architecture and
-C implementation for the accepted range and handling of overflow.
-\obindex{floating point}
-\indexii{floating point}{number}
-\index{C}
-
-\end{description} % Numbers
-
-\item[Sequences]
-These represent finite ordered sets indexed by natural numbers.
-The built-in function \verb@len()@ returns the number of elements
-of a sequence.  When this number is \var{n}, the index set contains
-the numbers 0, 1, \ldots, \var{n}-1.  Element \var{i} of sequence
-\var{a} is selected by \code{\var{a}[\var{i}]}.
-\obindex{seqence}
-\bifuncindex{len}
-\index{index operation}
-\index{item selection}
-\index{subscription}
-
-Sequences also support slicing: \verb@a[i:j]@ selects all elements
-with index \var{k} such that \var{i} \code{<=} \var{k} \code{<}
-\var{j}.  When used as an expression, a slice is a sequence of the
-same type --- this implies that the index set is renumbered so that it
-starts at 0 again.
-\index{slicing}
-
-Sequences are distinguished according to their mutability:
-
-\begin{description}
-%
-\item[Immutable sequences]
-An object of an immutable sequence type cannot change once it is
-created.  (If the object contains references to other objects,
-these other objects may be mutable and may be changed; however
-the collection of objects directly referenced by an immutable object
-cannot change.)
-\obindex{immutable sequence}
-\obindex{immutable}
-
-The following types are immutable sequences:
-
-\begin{description}
-
-\item[Strings]
-The elements of a string are characters.  There is no separate
-character type; a character is represented by a string of one element.
-Characters represent (at least) 8-bit bytes.  The built-in
-functions \verb@chr()@ and \verb@ord()@ convert between characters
-and nonnegative integers representing the byte values.
-Bytes with the values 0-127 represent the corresponding \ASCII{} values.
-The string data type is also used to represent arrays of bytes, e.g.
-to hold data read from a file.
-\obindex{string}
-\index{character}
-\index{byte}
-\index{ASCII}
-\bifuncindex{chr}
-\bifuncindex{ord}
-
-(On systems whose native character set is not \ASCII{}, strings may use
-EBCDIC in their internal representation, provided the functions
-\verb@chr()@ and \verb@ord()@ implement a mapping between \ASCII{} and
-EBCDIC, and string comparison preserves the \ASCII{} order.
-Or perhaps someone can propose a better rule?)
-\index{ASCII}
-\index{EBCDIC}
-\index{character set}
-\indexii{string}{comparison}
-\bifuncindex{chr}
-\bifuncindex{ord}
-
-\item[Tuples]
-The elements of a tuple are arbitrary Python objects.
-Tuples of two or more elements are formed by comma-separated lists
-of expressions.  A tuple of one element (a `singleton') can be formed
-by affixing a comma to an expression (an expression by itself does
-not create a tuple, since parentheses must be usable for grouping of
-expressions).  An empty tuple can be formed by enclosing `nothing' in
-parentheses.
-\obindex{tuple}
-\indexii{singleton}{tuple}
-\indexii{empty}{tuple}
-
-\end{description} % Immutable sequences
-
-\item[Mutable sequences]
-Mutable sequences can be changed after they are created.  The
-subscription and slicing notations can be used as the target of
-assignment and \verb@del@ (delete) statements.
-\obindex{mutable sequece}
-\obindex{mutable}
-\indexii{assignment}{statement}
-\index{delete}
-\stindex{del}
-\index{subscription}
-\index{slicing}
-
-There is currently a single mutable sequence type:
-
-\begin{description}
-
-\item[Lists]
-The elements of a list are arbitrary Python objects.  Lists are formed
-by placing a comma-separated list of expressions in square brackets.
-(Note that there are no special cases needed to form lists of length 0
-or 1.)
-\obindex{list}
-
-\end{description} % Mutable sequences
-
-\end{description} % Sequences
-
-\item[Mapping types]
-These represent finite sets of objects indexed by arbitrary index sets.
-The subscript notation \verb@a[k]@ selects the element indexed
-by \verb@k@ from the mapping \verb@a@; this can be used in
-expressions and as the target of assignments or \verb@del@ statements.
-The built-in function \verb@len()@ returns the number of elements
-in a mapping.
-\bifuncindex{len}
-\index{subscription}
-\obindex{mapping}
-
-There is currently a single mapping type:
-
-\begin{description}
-
-\item[Dictionaries]
-These represent finite sets of objects indexed by almost arbitrary
-values.  The only types of values not acceptable as keys are values
-containing lists or dictionaries or other mutable types that are
-compared by value rather than by object identity --- the reason being
-that the implementation requires that a key's hash value be constant.
-Numeric types used for keys obey the normal rules for numeric
-comparison: if two numbers compare equal (e.g. 1 and 1.0) then they
-can be used interchangeably to index the same dictionary entry.
-
-Dictionaries are mutable; they are created by the \verb@{...}@
-notation (see section \ref{dict}).
-\obindex{dictionary}
-\obindex{mutable}
-
-\end{description} % Mapping types
-
-\item[Callable types]
-These are the types to which the function call (invocation) operation,
-written as \verb@function(argument, argument, ...)@, can be applied:
-\indexii{function}{call}
-\index{invocation}
-\indexii{function}{argument}
-\obindex{callable}
-
-\begin{description}
-
-\item[User-defined functions]
-A user-defined function object is created by a function definition
-(see section \ref{function}).  It should be called with an argument
-list containing the same number of items as the function's formal
-parameter list.
-\indexii{user-defined}{function}
-\obindex{function}
-\obindex{user-defined function}
-
-Special read-only attributes: \verb@func_code@ is the code object
-representing the compiled function body, and \verb@func_globals@ is (a
-reference to) the dictionary that holds the function's global
-variables --- it implements the global name space of the module in
-which the function was defined.
-\ttindex{func_code}
-\ttindex{func_globals}
-\indexii{global}{name space}
-
-\item[User-defined methods]
-A user-defined method (a.k.a. {\em object closure}) is a pair of a
-class instance object and a user-defined function.  It should be
-called with an argument list containing one item less than the number
-of items in the function's formal parameter list.  When called, the
-class instance becomes the first argument, and the call arguments are
-shifted one to the right.
-\obindex{method}
-\obindex{user-defined method}
-\indexii{user-defined}{method}
-\index{object closure}
-
-Special read-only attributes: \verb@im_self@ is the class instance
-object, \verb@im_func@ is the function object.
-\ttindex{im_func}
-\ttindex{im_self}
-
-\item[Built-in functions]
-A built-in function object is a wrapper around a C function.  Examples
-of built-in functions are \verb@len@ and \verb@math.sin@.  There
-are no special attributes.  The number and type of the arguments are
-determined by the C function.
-\obindex{built-in function}
-\obindex{function}
-\index{C}
-
-\item[Built-in methods]
-This is really a different disguise of a built-in function, this time
-containing an object passed to the C function as an implicit extra
-argument.  An example of a built-in method is \verb@list.append@ if
-\verb@list@ is a list object.
-\obindex{built-in method}
-\obindex{method}
-\indexii{built-in}{method}
-
-\item[Classes]
-Class objects are described below.  When a class object is called as a
-function, a new class instance (also described below) is created and
-returned.  This implies a call to the class's \verb@__init__@ method
-if it has one.  Any arguments are passed on to the \verb@__init__@
-method --- if there is no \verb@__init__@ method, the class must be called
-without arguments.
-\ttindex{__init__}
-\obindex{class}
-\obindex{class instance}
-\obindex{instance}
-\indexii{class object}{call}
-
-\end{description}
-
-\item[Modules]
-Modules are imported by the \verb@import@ statement (see section
-\ref{import}).  A module object is a container for a module's name
-space, which is a dictionary (the same dictionary as referenced by the
-\verb@func_globals@ attribute of functions defined in the module).
-Module attribute references are translated to lookups in this
-dictionary.  A module object does not contain the code object used to
-initialize the module (since it isn't needed once the initialization
-is done).
-\stindex{import}
-\obindex{module}
-
-Attribute assignment update the module's name space dictionary.
-
-Special read-only attribute: \verb@__dict__@ yields the module's name
-space as a dictionary object.  Predefined attributes: \verb@__name__@
-yields the module's name as a string object; \verb@__doc__@ yields the
-module's documentation string as a string object, or
-\verb@None@ if no documentation string was found.
-\ttindex{__dict__}
-\ttindex{__name__}
-\ttindex{__doc__}
-\indexii{module}{name space}
-
-\item[Classes]
-Class objects are created by class definitions (see section
-\ref{class}).  A class is a container for a dictionary containing the
-class's name space.  Class attribute references are translated to
-lookups in this dictionary.  When an attribute name is not found
-there, the attribute search continues in the base classes.  The search
-is depth-first, left-to-right in the order of their occurrence in the
-base class list.
-\obindex{class}
-\obindex{class instance}
-\obindex{instance}
-\indexii{class object}{call}
-\index{container}
-\obindex{dictionary}
-\indexii{class}{attribute}
-
-Class attribute assignments update the class's dictionary, never the
-dictionary of a base class.
-\indexiii{class}{attribute}{assignment}
-
-A class can be called as a function to yield a class instance (see
-above).
-\indexii{class object}{call}
-
-Special read-only attributes: \verb@__dict__@ yields the dictionary
-containing the class's name space; \verb@__bases__@ yields a tuple
-(possibly empty or a singleton) containing the base classes, in the
-order of their occurrence in the base class list.
-\ttindex{__dict__}
-\ttindex{__bases__}
-
-\item[Class instances]
-A class instance is created by calling a class object as a
-function.  A class instance has a dictionary in which
-attribute references are searched.  When an attribute is not found
-there, and the instance's class has an attribute by that name, and
-that class attribute is a user-defined function (and in no other
-cases), the instance attribute reference yields a user-defined method
-object (see above) constructed from the instance and the function.
-\obindex{class instance}
-\obindex{instance}
-\indexii{class}{instance}
-\indexii{class instance}{attribute}
-
-Attribute assignments update the instance's dictionary.
-\indexiii{class instance}{attribute}{assignment}
-
-Class instances can pretend to be numbers, sequences, or mappings if
-they have methods with certain special names.  These are described in
-section \ref{specialnames}.
-\obindex{number}
-\obindex{sequence}
-\obindex{mapping}
-
-Special read-only attributes: \verb@__dict__@ yields the attribute
-dictionary; \verb@__class__@ yields the instance's class.
-\ttindex{__dict__}
-\ttindex{__class__}
-
-\item[Files]
-A file object represents an open file.  (It is a wrapper around a C
-{\tt stdio} file pointer.)  File objects are created by the
-\verb@open()@ built-in function, and also by \verb@posix.popen()@ and
-the \verb@makefile@ method of socket objects.  \verb@sys.stdin@,
-\verb@sys.stdout@ and \verb@sys.stderr@ are file objects corresponding
-to the interpreter's standard input, output and error streams.
-See the Python Library Reference for methods of file objects and other
-details.
-\obindex{file}
-\index{C}
-\index{stdio}
-\bifuncindex{open}
-\bifuncindex{popen}
-\bifuncindex{makefile}
-\ttindex{stdin}
-\ttindex{stdout}
-\ttindex{stderr}
-\ttindex{sys.stdin}
-\ttindex{sys.stdout}
-\ttindex{sys.stderr}
-
-\item[Internal types]
-A few types used internally by the interpreter are exposed to the user.
-Their definition may change with future versions of the interpreter,
-but they are mentioned here for completeness.
-\index{internal type}
-
-\begin{description}
-
-\item[Code objects]
-Code objects represent ``pseudo-compiled'' executable Python code.
-The difference between a code
-object and a function object is that the function object contains an
-explicit reference to the function's context (the module in which it
-was defined) while a code object contains no context.
-\obindex{code}
-
-Special read-only attributes: \verb@co_code@ is a string representing
-the sequence of instructions; \verb@co_consts@ is a list of literals
-used by the code; \verb@co_names@ is a list of names (strings) used by
-the code; \verb@co_filename@ is the filename from which the code was
-compiled.  (To find out the line numbers, you would have to decode the
-instructions; the standard library module \verb@dis@ contains an
-example of how to do this.)
-\ttindex{co_code}
-\ttindex{co_consts}
-\ttindex{co_names}
-\ttindex{co_filename}
-
-\item[Frame objects]
-Frame objects represent execution frames.  They may occur in traceback
-objects (see below).
-\obindex{frame}
-
-Special read-only attributes: \verb@f_back@ is to the previous
-stack frame (towards the caller), or \verb@None@ if this is the bottom
-stack frame; \verb@f_code@ is the code object being executed in this
-frame; \verb@f_globals@ is the dictionary used to look up global
-variables; \verb@f_locals@ is used for local variables;
-\verb@f_lineno@ gives the line number and \verb@f_lasti@ gives the
-precise instruction (this is an index into the instruction string of
-the code object).
-\ttindex{f_back}
-\ttindex{f_code}
-\ttindex{f_globals}
-\ttindex{f_locals}
-\ttindex{f_lineno}
-\ttindex{f_lasti}
-
-\item[Traceback objects] \label{traceback}
-Traceback objects represent a stack trace of an exception.  A
-traceback object is created when an exception occurs.  When the search
-for an exception handler unwinds the execution stack, at each unwound
-level a traceback object is inserted in front of the current
-traceback.  When an exception handler is entered
-(see also section \ref{try}), the stack trace is
-made available to the program as \verb@sys.exc_traceback@.  When the
-program contains no suitable handler, the stack trace is written
-(nicely formatted) to the standard error stream; if the interpreter is
-interactive, it is also made available to the user as
-\verb@sys.last_traceback@.
-\obindex{traceback}
-\indexii{stack}{trace}
-\indexii{exception}{handler}
-\indexii{execution}{stack}
-\ttindex{exc_traceback}
-\ttindex{last_traceback}
-\ttindex{sys.exc_traceback}
-\ttindex{sys.last_traceback}
-
-Special read-only attributes: \verb@tb_next@ is the next level in the
-stack trace (towards the frame where the exception occurred), or
-\verb@None@ if there is no next level; \verb@tb_frame@ points to the
-execution frame of the current level; \verb@tb_lineno@ gives the line
-number where the exception occurred; \verb@tb_lasti@ indicates the
-precise instruction.  The line number and last instruction in the
-traceback may differ from the line number of its frame object if the
-exception occurred in a \verb@try@ statement with no matching
-\verb@except@ clause or with a \verb@finally@ clause.
-\ttindex{tb_next}
-\ttindex{tb_frame}
-\ttindex{tb_lineno}
-\ttindex{tb_lasti}
-\stindex{try}
-
-\end{description} % Internal types
-
-\end{description} % Types
-
-
-\section{Special method names} \label{specialnames}
-
-A class can implement certain operations that are invoked by special
-syntax (such as subscription or arithmetic operations) by defining
-methods with special names.  For instance, if a class defines a
-method named \verb@__getitem__@, and \verb@x@ is an instance of this
-class, then \verb@x[i]@ is equivalent to \verb@x.__getitem__(i)@.
-(The reverse is not true --- if \verb@x@ is a list object,
-\verb@x.__getitem__(i)@ is not equivalent to \verb@x[i]@.)
-\ttindex{__getitem__}
-
-Except for \verb@__repr__@, \verb@__str__@ and \verb@__cmp__@,
-attempts to execute an
-operation raise an exception when no appropriate method is defined.
-For \verb@__repr__@, the default is to return a string describing the
-object's class and address.
-For \verb@__cmp__@, the default is to compare instances based on their
-address.
-For \verb@__str__@, the default is to use \verb@__repr__@.
-\ttindex{__repr__}
-\ttindex{__str__}
-\ttindex{__cmp__}
-
-
-\subsection{Special methods for any type}
-
-\begin{description}
-
-\item[{\tt __init__(self, args...)}]
-Called when the instance is created.  The arguments are those passed
-to the class constructor expression.  If a base class has an
-\code{__init__} method the derived class's \code{__init__} method must
-explicitly call it to ensure proper initialization of the base class
-part of the instance.
-\ttindex{__init__}
-\indexii{class}{constructor}
-
-
-\item[{\tt __del__(self)}]
-Called when the instance is about to be destroyed.  If a base class
-has an \code{__del__} method the derived class's \code{__del__} method
-must explicitly call it to ensure proper deletion of the base class
-part of the instance.  Note that it is possible for the \code{__del__}
-method to postpone destruction of the instance by creating a new
-reference to it.  It may then be called at a later time when this new
-reference is deleted.  It is not guaranteed that
-\code{__del__} methods are called for objects that still exist when
-the interpreter exits.
-If an exception occurs in a \code{__del__} method, it is ignored, and
-a warning is printed on stderr.
-\ttindex{__del__}
-\stindex{del}
-
-Note that \code{del x} doesn't directly call \code{x.__del__} --- the
-former decrements the reference count for \code{x} by one, but
-\code{x.__del__} is only called when its reference count reaches zero.
-
-\strong{Warning:} due to the precarious circumstances under which
-\code{__del__} methods are executed, exceptions that occur during
-their execution are \emph{ignored}.
-
-\item[{\tt __repr__(self)}]
-Called by the \verb@repr()@ built-in function and by string conversions
-(reverse or backward quotes) to compute the string representation of an object.
-\ttindex{__repr__}
-\bifuncindex{repr}
-\indexii{string}{conversion}
-\indexii{reverse}{quotes}
-\indexii{backward}{quotes}
-\index{back-quotes}
-
-\item[{\tt __str__(self)}]
-Called by the \verb@str()@ built-in function and by the \verb@print@
-statement compute the string representation of an object.
-\ttindex{__str__}
-\bifuncindex{str}
-\stindex{print}
-
-\item[{\tt __cmp__(self, other)}]
-Called by all comparison operations.  Should return -1 if
-\verb@self < other@,  0 if \verb@self == other@, +1 if
-\verb@self > other@.  If no \code{__cmp__} operation is defined, class
-instances are compared by object identity (``address'').
-(Implementation note: due to limitations in the interpreter,
-exceptions raised by comparisons are ignored, and the objects will be
-considered equal in this case.)
-\ttindex{__cmp__}
-\bifuncindex{cmp}
-\index{comparisons}
-
-\item[{\tt __hash__(self)}]
-Called for the key object for dictionary operations,
-and by the built-in function
-\code{hash()}.  Should return a 32-bit integer usable as a hash value
-for dictionary operations.  The only required property is that objects
-which compare equal have the same hash value; it is advised to somehow
-mix together (e.g. using exclusive or) the hash values for the
-components of the object that also play a part in comparison of
-objects.  If a class does not define a \code{__cmp__} method it should
-not define a \code{__hash__} operation either; if it defines
-\code{__cmp__} but not \code{__hash__} its instances will not be
-usable as dictionary keys.  If a class defines mutable objects and
-implements a \code{__cmp__} method it should not implement
-\code{__hash__}, since the dictionary implementation assumes that a
-key's hash value is a constant.
-\obindex{dictionary}
-\ttindex{__cmp__}
-\ttindex{__hash__}
-\bifuncindex{hash}
-
-\item[{\tt __call__(self, *args)}]
-Called when the instance is ``called'' as a function.
-\ttindex{__call__}
-\indexii{call}{instance}
-
-\end{description}
-
-
-\subsection{Special methods for attribute access}
-
-The following methods can be used to change the meaning of attribute
-access for class instances.
-
-\begin{description}
-
-\item[{\tt __getattr__(self, name)}]
-Called when an attribute lookup has not found the attribute in the
-usual places (i.e. it is not an instance attribute nor is it found in
-the class tree for \code{self}).  \code{name} is the attribute name.
-\ttindex{__getattr__}
-
-Note that if the attribute is found through the normal mechanism,
-\code{__getattr__} is not called.  (This is an asymmetry between
-\code{__getattr__} and \code{__setattr__}.)
-This is done both for efficiency reasons and because otherwise
-\code{__getattr__} would have no way to access other attributes of the
-instance.
-Note that at least for instance variables, \code{__getattr__} can fake
-total control by simply not inserting any values in the instance
-attribute dictionary.
-\ttindex{__setattr__}
-
-\item[{\tt __setattr__(self, name, value)}]
-Called when an attribute assignment is attempted.  This is called
-instead of the normal mechanism (i.e. store the value as an instance
-attribute).  \code{name} is the attribute name, \code{value} is the
-value to be assigned to it.
-\ttindex{__setattr__}
-
-If \code{__setattr__} wants to assign to an instance attribute, it
-should not simply execute \code{self.\var{name} = value} --- this would
-cause a recursive call.  Instead, it should insert the value in the
-dictionary of instance attributes, e.g. \code{self.__dict__[name] =
-value}.
-\ttindex{__dict__}
-
-\item[{\tt __delattr__(self, name)}]
-Like \code{__setattr__} but for attribute deletion instead of
-assignment.
-\ttindex{__delattr__}
-
-\end{description}
-
-
-\subsection{Special methods for sequence and mapping types}
-
-\begin{description}
-
-\item[{\tt __len__(self)}]
-Called to implement the built-in function \verb@len()@.  Should return
-the length of the object, an integer \verb@>=@ 0.  Also, an object
-whose \verb@__len__()@ method returns 0 is considered to be false in a
-Boolean context.
-\ttindex{__len__}
-
-\item[{\tt __getitem__(self, key)}]
-Called to implement evaluation of \verb@self[key]@.  Note that the
-special interpretation of negative keys (if the class wishes to
-emulate a sequence type) is up to the \verb@__getitem__@ method.
-\ttindex{__getitem__}
-
-\item[{\tt __setitem__(self, key, value)}]
-Called to implement assignment to \verb@self[key]@.  Same note as for
-\verb@__getitem__@.
-\ttindex{__setitem__}
-
-\item[{\tt __delitem__(self, key)}]
-Called to implement deletion of \verb@self[key]@.  Same note as for
-\verb@__getitem__@.
-\ttindex{__delitem__}
-
-\end{description}
-
-
-\subsection{Special methods for sequence types}
-
-\begin{description}
-
-\item[{\tt __getslice__(self, i, j)}]
-Called to implement evaluation of \verb@self[i:j]@.  Note that missing
-\verb@i@ or \verb@j@ are replaced by 0 or \verb@len(self)@,
-respectively, and \verb@len(self)@ has been added (once) to originally
-negative \verb@i@ or \verb@j@ by the time this function is called
-(unlike for \verb@__getitem__@).
-\ttindex{__getslice__}
-
-\item[{\tt __setslice__(self, i, j, sequence)}]
-Called to implement assignment to \verb@self[i:j]@.  Same notes as for
-\verb@__getslice__@.
-\ttindex{__setslice__}
-
-\item[{\tt __delslice__(self, i, j)}]
-Called to implement deletion of \verb@self[i:j]@.  Same notes as for
-\verb@__getslice__@.
-\ttindex{__delslice__}
-
-\end{description}
-
-
-\subsection{Special methods for numeric types}
-
-\begin{description}
-
-\item[{\tt __add__(self, other)}]\itemjoin
-\item[{\tt __sub__(self, other)}]\itemjoin
-\item[{\tt __mul__(self, other)}]\itemjoin
-\item[{\tt __div__(self, other)}]\itemjoin
-\item[{\tt __mod__(self, other)}]\itemjoin
-\item[{\tt __divmod__(self, other)}]\itemjoin
-\item[{\tt __pow__(self, other)}]\itemjoin
-\item[{\tt __lshift__(self, other)}]\itemjoin
-\item[{\tt __rshift__(self, other)}]\itemjoin
-\item[{\tt __and__(self, other)}]\itemjoin
-\item[{\tt __xor__(self, other)}]\itemjoin
-\item[{\tt __or__(self, other)}]\itembreak
-Called to implement the binary arithmetic operations (\verb@+@,
-\verb@-@, \verb@*@, \verb@/@, \verb@%@, \verb@divmod()@, \verb@pow()@,
-\verb@<<@, \verb@>>@, \verb@&@, \verb@^@, \verb@|@).
-\ttindex{__or__}
-\ttindex{__xor__}
-\ttindex{__and__}
-\ttindex{__rshift__}
-\ttindex{__lshift__}
-\ttindex{__pow__}
-\ttindex{__divmod__}
-\ttindex{__mod__}
-\ttindex{__div__}
-\ttindex{__mul__}
-\ttindex{__sub__}
-\ttindex{__add__}
-
-\item[{\tt __neg__(self)}]\itemjoin
-\item[{\tt __pos__(self)}]\itemjoin
-\item[{\tt __abs__(self)}]\itemjoin
-\item[{\tt __invert__(self)}]\itembreak
-Called to implement the unary arithmetic operations (\verb@-@, \verb@+@,
-\verb@abs()@ and \verb@~@).
-\ttindex{__invert__}
-\ttindex{__abs__}
-\ttindex{__pos__}
-\ttindex{__neg__}
-
-\item[{\tt __nonzero__(self)}]
-Called to implement boolean testing; should return 0 or 1.  An
-alternative name for this method is \verb@__len__@.
-\ttindex{__nonzero__}
-
-\item[{\tt __coerce__(self, other)}]
-Called to implement ``mixed-mode'' numeric arithmetic.  Should either
-return a tuple containing self and other converted to a common numeric
-type, or None if no way of conversion is known.  When the common type
-would be the type of other, it is sufficient to return None, since the
-interpreter will also ask the other object to attempt a coercion (but
-sometimes, if the implementation of the other type cannot be changed,
-it is useful to do the conversion to the other type here).
-\ttindex{__coerce__}
-
-Note that this method is not called to coerce the arguments to \verb@+@
-and \verb@*@, because these are also used to implement sequence
-concatenation and repetition, respectively.  Also note that, for the
-same reason, in \verb@n*x@, where \verb@n@ is a built-in number and
-\verb@x@ is an instance, a call to \verb@x.__mul__(n)@ is made.%
-\footnote{The interpreter should really distinguish between
-user-defined classes implementing sequences, mappings or numbers, but
-currently it doesn't --- hence this strange exception.}
-\ttindex{__mul__}
-
-\item[{\tt __int__(self)}]\itemjoin
-\item[{\tt __long__(self)}]\itemjoin
-\item[{\tt __float__(self)}]\itembreak
-Called to implement the built-in functions \verb@int()@, \verb@long()@
-and \verb@float()@.  Should return a value of the appropriate type.
-\ttindex{__float__}
-\ttindex{__long__}
-\ttindex{__int__}
-
-\item[{\tt __oct__(self)}]\itemjoin
-\item[{\tt __hex__(self)}]\itembreak
-Called to implement the built-in functions \verb@oct()@ and
-\verb@hex()@.  Should return a string value.
-\ttindex{__hex__}
-\ttindex{__oct__}
-
-\end{description}
diff --git a/Doc/ref/ref4.tex b/Doc/ref/ref4.tex
deleted file mode 100644
index 4b4d522..0000000
--- a/Doc/ref/ref4.tex
+++ /dev/null
@@ -1,201 +0,0 @@
-\chapter{Execution model}
-\index{execution model}
-
-\section{Code blocks, execution frames, and name spaces} \label{execframes}
-\index{code block}
-\indexii{execution}{frame}
-\index{name space}
-
-A {\em code block} is a piece of Python program text that can be
-executed as a unit, such as a module, a class definition or a function
-body.  Some code blocks (like modules) are executed only once, others
-(like function bodies) may be executed many times.  Code blocks may
-textually contain other code blocks.  Code blocks may invoke other
-code blocks (that may or may not be textually contained in them) as
-part of their execution, e.g. by invoking (calling) a function.
-\index{code block}
-\indexii{code}{block}
-
-The following are code blocks:  A module is a code block.  A function
-body is a code block.  A class definition is a code block.  Each
-command typed interactively is a separate code block; a script file is
-a code block.  The string argument passed to the built-in function
-\verb@eval@ and to the \verb@exec@ statement are code blocks.
-And finally, the
-expression read and evaluated by the built-in function \verb@input@ is
-a code block.
-
-A code block is executed in an execution frame.  An {\em execution
-frame} contains some administrative information (used for debugging),
-determines where and how execution continues after the code block's
-execution has completed, and (perhaps most importantly) defines two
-name spaces, the local and the global name space, that affect
-execution of the code block.
-\indexii{execution}{frame}
-
-A {\em name space} is a mapping from names (identifiers) to objects.
-A particular name space may be referenced by more than one execution
-frame, and from other places as well.  Adding a name to a name space
-is called {\em binding} a name (to an object); changing the mapping of
-a name is called {\em rebinding}; removing a name is {\em unbinding}.
-Name spaces are functionally equivalent to dictionaries.
-\index{name space}
-\indexii{binding}{name}
-\indexii{rebinding}{name}
-\indexii{unbinding}{name}
-
-The {\em local name space} of an execution frame determines the default
-place where names are defined and searched.  The {\em global name
-space} determines the place where names listed in \verb@global@
-statements are defined and searched, and where names that are not
-explicitly bound in the current code block are searched.
-\indexii{local}{name space}
-\indexii{global}{name space}
-\stindex{global}
-
-Whether a name is local or global in a code block is determined by
-static inspection of the source text for the code block: in the
-absence of \verb@global@ statements, a name that is bound anywhere in
-the code block is local in the entire code block; all other names are
-considered global.  The \verb@global@ statement forces global
-interpretation of selected names throughout the code block.  The
-following constructs bind names: formal parameters, \verb@import@
-statements, class and function definitions (these bind the class or
-function name), and targets that are identifiers if occurring in an
-assignment, \verb@for@ loop header, or \verb@except@ clause header.
-
-A target occurring in a \verb@del@ statement is also considered bound
-for this purpose (though the actual semantics are to ``unbind'' the
-name).
-
-When a global name is not found in the global name space, it is
-searched in the list of ``built-in'' names (which is actually the
-global name space of the module \verb@__builtin__@).  When a name is not
-found at all, the \verb@NameError@ exception is raised.%
-\footnote{If the code block contains {\tt exec} statements or the
-construct {\tt from \ldots import *}, the semantics of names not
-explicitly mentioned in a {\tt global} statement change subtly: name
-lookup first searches the local name space, then the global one, then
-the built-in one.}
-\bimodindex{__builtin__}
-\stindex{from}
-\stindex{exec}
-\stindex{global}
-\ttindex{NameError}
-
-The following table lists the meaning of the local and global name
-space for various types of code blocks.  The name space for a
-particular module is automatically created when the module is first
-referenced.  Note that in almost all cases, the global name space is
-the name space of the containing module --- scopes in Python do not
-nest!
-
-\begin{center}
-\begin{tabular}{|l|l|l|l|}
-\hline
-Code block type & Global name space & Local name space & Notes \\
-\hline
-Module & n.s. for this module & same as global & \\
-Script & n.s. for \verb@__main__@ & same as global & \\
-Interactive command & n.s. for \verb@__main__@ & same as global & \\
-Class definition & global n.s. of containing block & new n.s. & \\
-Function body & global n.s. of containing block & new n.s. & (2) \\
-String passed to \verb@exec@ statement
-	& global n.s. of containing block
-		& local n.s. of containing block & (1) \\
-String passed to \verb@eval()@
-	& global n.s. of caller & local n.s. of caller & (1) \\
-File read by \verb@execfile()@
-	& global n.s. of caller & local n.s. of caller & (1) \\
-Expression read by \verb@input@
-	& global n.s. of caller & local n.s. of caller & \\
-\hline
-\end{tabular}
-\end{center}
-\bimodindex{__main__}
-
-Notes:
-
-\begin{description}
-
-\item[n.s.] means {\em name space}
-
-\item[(1)] The global and local name space for these can be
-overridden with optional extra arguments.
-
-\item[(2)] The body of lambda forms (see section \ref{lambda}) is
-treated exactly the same as a (nested) function definition.  Lambda
-forms have their own name space consisting of their formal arguments.
-\indexii{lambda}{form}
-
-\end{description}
-
-The built-in functions \verb@globals()@ and \verb@locals()@ returns a
-dictionary representing the current global and local name space,
-respectively.  The effect of modifications to this dictionary on the
-name space are undefined.%
-\footnote{The current implementations return the dictionary actually 
-used to implement the name space, {\em except} for functions, where
-the optimizer may cause the local name space to be implemented
-differently, and \verb@locals()@ returns a read-only dictionary.}
-
-\section{Exceptions}
-
-Exceptions are a means of breaking out of the normal flow of control
-of a code block in order to handle errors or other exceptional
-conditions.  An exception is {\em raised} at the point where the error
-is detected; it may be {\em handled} by the surrounding code block or
-by any code block that directly or indirectly invoked the code block
-where the error occurred.
-\index{exception}
-\index{raise an exception}
-\index{handle an exception}
-\index{exception handler}
-\index{errors}
-\index{error handling}
-
-The Python interpreter raises an exception when it detects an run-time
-error (such as division by zero).  A Python program can also
-explicitly raise an exception with the \verb@raise@ statement.
-Exception handlers are specified with the \verb@try...except@
-statement.
-
-Python uses the ``termination'' model of error handling: an exception
-handler can find out what happened and continue execution at an outer
-level, but it cannot repair the cause of the error and retry the
-failing operation (except by re-entering the the offending piece of
-code from the top).
-
-When an exception is not handled at all, the interpreter terminates
-execution of the program, or returns to its interactive main loop.
-
-Exceptions are identified by string objects or class instances.  Two
-different string objects with the same value identify different
-exceptions.  An exception can be raised with a class instance.  Such
-exceptions are caught by specifying an except clause that has the
-class name (or a base class) as the condition.
-
-When an exception is raised, an object (maybe \verb@None@) is passed
-as the exception's ``parameter''; this object does not affect the
-selection of an exception handler, but is passed to the selected
-exception handler as additional information.  For exceptions raised
-with a class instance, the instance is passed as the ``parameter''.
-
-For example:
-
-\begin{verbatim}
->>> class Error:
-...     def __init__(self, msg): self.msg = msg
-... 
->>> class SpecificError(Error): pass
-... 
->>> try:
-...     raise SpecificError('broken')
-... except Error, obj:
-...     print obj.msg
-... 
-broken
-\end{verbatim}
-
-See also the description of the \verb@try@ and \verb@raise@
-statements.
diff --git a/Doc/ref/ref5.tex b/Doc/ref/ref5.tex
deleted file mode 100644
index b2fea3c..0000000
--- a/Doc/ref/ref5.tex
+++ /dev/null
@@ -1,759 +0,0 @@
-\chapter{Expressions and conditions}
-\index{expression}
-\index{condition}
-
-{\bf Note:} In this and the following chapters, extended BNF notation
-will be used to describe syntax, not lexical analysis.
-\index{BNF}
-
-This chapter explains the meaning of the elements of expressions and
-conditions.  Conditions are a superset of expressions, and a condition
-may be used wherever an expression is required by enclosing it in
-parentheses.  The only places where expressions are used in the syntax
-instead of conditions is in expression statements and on the
-right-hand side of assignment statements; this catches some nasty bugs
-like accidentally writing \verb@x == 1@ instead of \verb@x = 1@.
-\indexii{assignment}{statement}
-
-The comma plays several roles in Python's syntax.  It is usually an
-operator with a lower precedence than all others, but occasionally
-serves other purposes as well; e.g. it separates function arguments,
-is used in list and dictionary constructors, and has special semantics
-in \verb@print@ statements.
-\index{comma}
-
-When (one alternative of) a syntax rule has the form
-
-\begin{verbatim}
-name:           othername
-\end{verbatim}
-
-and no semantics are given, the semantics of this form of \verb@name@
-are the same as for \verb@othername@.
-\index{syntax}
-
-\section{Arithmetic conversions}
-\indexii{arithmetic}{conversion}
-
-When a description of an arithmetic operator below uses the phrase
-``the numeric arguments are converted to a common type'',
-this both means that if either argument is not a number, a
-\verb@TypeError@ exception is raised, and that otherwise
-the following conversions are applied:
-\exindex{TypeError}
-\indexii{floating point}{number}
-\indexii{long}{integer}
-\indexii{plain}{integer}
-
-\begin{itemize}
-\item	first, if either argument is a floating point number,
-	the other is converted to floating point;
-\item	else, if either argument is a long integer,
-	the other is converted to long integer;
-\item	otherwise, both must be plain integers and no conversion
-	is necessary.
-\end{itemize}
-
-\section{Atoms}
-\index{atom}
-
-Atoms are the most basic elements of expressions.  Forms enclosed in
-reverse quotes or in parentheses, brackets or braces are also
-categorized syntactically as atoms.  The syntax for atoms is:
-
-\begin{verbatim}
-atom:      identifier | literal | enclosure
-enclosure: parenth_form|list_display|dict_display|string_conversion
-\end{verbatim}
-
-\subsection{Identifiers (Names)}
-\index{name}
-\index{identifier}
-
-An identifier occurring as an atom is a reference to a local, global
-or built-in name binding.  If a name is assigned to anywhere in a code
-block (even in unreachable code), and is not mentioned in a
-\verb@global@ statement in that code block, then it refers to a local
-name throughout that code block.  When it is not assigned to anywhere
-in the block, or when it is assigned to but also explicitly listed in
-a \verb@global@ statement, it refers to a global name if one exists,
-else to a built-in name (and this binding may dynamically change).
-\indexii{name}{binding}
-\index{code block}
-\stindex{global}
-\indexii{built-in}{name}
-\indexii{global}{name}
-
-When the name is bound to an object, evaluation of the atom yields
-that object.  When a name is not bound, an attempt to evaluate it
-raises a \verb@NameError@ exception.
-\exindex{NameError}
-
-\subsection{Literals}
-\index{literal}
-
-Python knows string and numeric literals:
-
-\begin{verbatim}
-literal:        stringliteral | integer | longinteger | floatnumber
-\end{verbatim}
-
-Evaluation of a literal yields an object of the given type (string,
-integer, long integer, floating point number) with the given value.
-The value may be approximated in the case of floating point literals.
-See section \ref{literals} for details.
-
-All literals correspond to immutable data types, and hence the
-object's identity is less important than its value.  Multiple
-evaluations of literals with the same value (either the same
-occurrence in the program text or a different occurrence) may obtain
-the same object or a different object with the same value.
-\indexiii{immutable}{data}{type}
-
-(In the original implementation, all literals in the same code block
-with the same type and value yield the same object.)
-
-\subsection{Parenthesized forms}
-\index{parenthesized form}
-
-A parenthesized form is an optional condition list enclosed in
-parentheses:
-
-\begin{verbatim}
-parenth_form:      "(" [condition_list] ")"
-\end{verbatim}
-
-A parenthesized condition list yields whatever that condition list
-yields.
-
-An empty pair of parentheses yields an empty tuple object.  Since
-tuples are immutable, the rules for literals apply here.
-\indexii{empty}{tuple}
-
-(Note that tuples are not formed by the parentheses, but rather by use
-of the comma operator.  The exception is the empty tuple, for which
-parentheses {\em are} required --- allowing unparenthesized ``nothing''
-in expressions would cause ambiguities and allow common typos to
-pass uncaught.)
-\index{comma}
-\indexii{tuple}{display}
-
-\subsection{List displays}
-\indexii{list}{display}
-
-A list display is a possibly empty series of conditions enclosed in
-square brackets:
-
-\begin{verbatim}
-list_display:   "[" [condition_list] "]"
-\end{verbatim}
-
-A list display yields a new list object.
-\obindex{list}
-
-If it has no condition list, the list object has no items.  Otherwise,
-the elements of the condition list are evaluated from left to right
-and inserted in the list object in that order.
-\indexii{empty}{list}
-
-\subsection{Dictionary displays} \label{dict}
-\indexii{dictionary}{display}
-
-A dictionary display is a possibly empty series of key/datum pairs
-enclosed in curly braces:
-\index{key}
-\index{datum}
-\index{key/datum pair}
-
-\begin{verbatim}
-dict_display:   "{" [key_datum_list] "}"
-key_datum_list: key_datum ("," key_datum)* [","]
-key_datum:      condition ":" condition
-\end{verbatim}
-
-A dictionary display yields a new dictionary object.
-\obindex{dictionary}
-
-The key/datum pairs are evaluated from left to right to define the
-entries of the dictionary: each key object is used as a key into the
-dictionary to store the corresponding datum.
-
-Restrictions on the types of the key values are listed earlier in
-section \ref{types}.
-Clashes between duplicate keys are not detected; the last
-datum (textually rightmost in the display) stored for a given key
-value prevails.
-\exindex{TypeError}
-
-\subsection{String conversions}
-\indexii{string}{conversion}
-\indexii{reverse}{quotes}
-\indexii{backward}{quotes}
-\index{back-quotes}
-
-A string conversion is a condition list enclosed in reverse (or
-backward) quotes:
-
-\begin{verbatim}
-string_conversion: "`" condition_list "`"
-\end{verbatim}
-
-A string conversion evaluates the contained condition list and
-converts the resulting object into a string according to rules
-specific to its type.
-
-If the object is a string, a number, \verb@None@, or a tuple, list or
-dictionary containing only objects whose type is one of these, the
-resulting string is a valid Python expression which can be passed to
-the built-in function \verb@eval()@ to yield an expression with the
-same value (or an approximation, if floating point numbers are
-involved).
-
-(In particular, converting a string adds quotes around it and converts
-``funny'' characters to escape sequences that are safe to print.)
-
-It is illegal to attempt to convert recursive objects (e.g. lists or
-dictionaries that contain a reference to themselves, directly or
-indirectly.)
-\obindex{recursive}
-
-The built-in function \verb@repr()@ performs exactly the same
-conversion in its argument as enclosing it it reverse quotes does.
-The built-in function \verb@str()@ performs a similar but more
-user-friendly conversion.
-\bifuncindex{repr}
-\bifuncindex{str}
-
-\section{Primaries} \label{primaries}
-\index{primary}
-
-Primaries represent the most tightly bound operations of the language.
-Their syntax is:
-
-\begin{verbatim}
-primary:        atom | attributeref | subscription | slicing | call
-\end{verbatim}
-
-\subsection{Attribute references}
-\indexii{attribute}{reference}
-
-An attribute reference is a primary followed by a period and a name:
-
-\begin{verbatim}
-attributeref:   primary "." identifier
-\end{verbatim}
-
-The primary must evaluate to an object of a type that supports
-attribute references, e.g. a module or a list.  This object is then
-asked to produce the attribute whose name is the identifier.  If this
-attribute is not available, the exception \verb@AttributeError@ is
-raised.  Otherwise, the type and value of the object produced is
-determined by the object.  Multiple evaluations of the same attribute
-reference may yield different objects.
-\obindex{module}
-\obindex{list}
-
-\subsection{Subscriptions}
-\index{subscription}
-
-A subscription selects an item of a sequence (string, tuple or list)
-or mapping (dictionary) object:
-\obindex{sequence}
-\obindex{mapping}
-\obindex{string}
-\obindex{tuple}
-\obindex{list}
-\obindex{dictionary}
-\indexii{sequence}{item}
-
-\begin{verbatim}
-subscription:   primary "[" condition "]"
-\end{verbatim}
-
-The primary must evaluate to an object of a sequence or mapping type.
-
-If it is a mapping, the condition must evaluate to an object whose
-value is one of the keys of the mapping, and the subscription selects
-the value in the mapping that corresponds to that key.
-
-If it is a sequence, the condition must evaluate to a plain integer.
-If this value is negative, the length of the sequence is added to it
-(so that, e.g. \verb@x[-1]@ selects the last item of \verb@x@.)
-The resulting value must be a nonnegative integer smaller than the
-number of items in the sequence, and the subscription selects the item
-whose index is that value (counting from zero).
-
-A string's items are characters.  A character is not a separate data
-type but a string of exactly one character.
-\index{character}
-\indexii{string}{item}
-
-\subsection{Slicings}
-\index{slicing}
-\index{slice}
-
-A slicing (or slice) selects a range of items in a sequence (string,
-tuple or list) object:
-\obindex{sequence}
-\obindex{string}
-\obindex{tuple}
-\obindex{list}
-
-\begin{verbatim}
-slicing:        primary "[" [condition] ":" [condition] "]"
-\end{verbatim}
-
-The primary must evaluate to a sequence object.  The lower and upper
-bound expressions, if present, must evaluate to plain integers;
-defaults are zero and the sequence's length, respectively.  If either
-bound is negative, the sequence's length is added to it.  The slicing
-now selects all items with index \var{k} such that
-\code{\var{i} <= \var{k} < \var{j}} where \var{i}
-and \var{j} are the specified lower and upper bounds.  This may be an
-empty sequence.  It is not an error if \var{i} or \var{j} lie outside the
-range of valid indexes (such items don't exist so they aren't
-selected).
-
-\subsection{Calls} \label{calls}
-\index{call}
-
-A call calls a callable object (e.g. a function) with a possibly empty
-series of arguments:\footnote{The new syntax for keyword arguments is
-not yet documented in this manual.  See chapter 12 of the Tutorial.}
-\obindex{callable}
-
-\begin{verbatim}
-call:           primary "(" [condition_list] ")"
-\end{verbatim}
-
-The primary must evaluate to a callable object (user-defined
-functions, built-in functions, methods of built-in objects, class
-objects, and methods of class instances are callable).  If it is a
-class, the argument list must be empty; otherwise, the arguments are
-evaluated.
-
-A call always returns some value, possibly \verb@None@, unless it
-raises an exception.  How this value is computed depends on the type
-of the callable object.  If it is:
-
-\begin{description}
-
-\item[a user-defined function:] the code block for the function is
-executed, passing it the argument list.  The first thing the code
-block will do is bind the formal parameters to the arguments; this is
-described in section \ref{function}.  When the code block executes a
-\verb@return@ statement, this specifies the return value of the
-function call.
-\indexii{function}{call}
-\indexiii{user-defined}{function}{call}
-\obindex{user-defined function}
-\obindex{function}
-
-\item[a built-in function or method:] the result is up to the
-interpreter; see the library reference manual for the descriptions of
-built-in functions and methods.
-\indexii{function}{call}
-\indexii{built-in function}{call}
-\indexii{method}{call}
-\indexii{built-in method}{call}
-\obindex{built-in method}
-\obindex{built-in function}
-\obindex{method}
-\obindex{function}
-
-\item[a class object:] a new instance of that class is returned.
-\obindex{class}
-\indexii{class object}{call}
-
-\item[a class instance method:] the corresponding user-defined
-function is called, with an argument list that is one longer than the
-argument list of the call: the instance becomes the first argument.
-\obindex{class instance}
-\obindex{instance}
-\indexii{instance}{call}
-\indexii{class instance}{call}
-
-\end{description}
-
-\section{Unary arithmetic operations}
-\indexiii{unary}{arithmetic}{operation}
-\indexiii{unary}{bit-wise}{operation}
-
-All unary arithmetic (and bit-wise) operations have the same priority:
-
-\begin{verbatim}
-u_expr:         primary | "-" u_expr | "+" u_expr | "~" u_expr
-\end{verbatim}
-
-The unary \verb@"-"@ (minus) operator yields the negation of its
-numeric argument.
-\index{negation}
-\index{minus}
-
-The unary \verb@"+"@ (plus) operator yields its numeric argument
-unchanged.
-\index{plus}
-
-The unary \verb@"~"@ (invert) operator yields the bit-wise inversion
-of its plain or long integer argument.  The bit-wise inversion of
-\verb@x@ is defined as \verb@-(x+1)@.
-\index{inversion}
-
-In all three cases, if the argument does not have the proper type,
-a \verb@TypeError@ exception is raised.
-\exindex{TypeError}
-
-\section{Binary arithmetic operations}
-\indexiii{binary}{arithmetic}{operation}
-
-The binary arithmetic operations have the conventional priority
-levels.  Note that some of these operations also apply to certain
-non-numeric types.  There is no ``power'' operator, so there are only
-two levels, one for multiplicative operators and one for additive
-operators:
-
-\begin{verbatim}
-m_expr:         u_expr | m_expr "*" u_expr
-              | m_expr "/" u_expr | m_expr "%" u_expr
-a_expr:         m_expr | aexpr "+" m_expr | aexpr "-" m_expr
-\end{verbatim}
-
-The \verb@"*"@ (multiplication) operator yields the product of its
-arguments.  The arguments must either both be numbers, or one argument
-must be a plain integer and the other must be a sequence.  In the
-former case, the numbers are converted to a common type and then
-multiplied together.  In the latter case, sequence repetition is
-performed; a negative repetition factor yields an empty sequence.
-\index{multiplication}
-
-The \verb@"/"@ (division) operator yields the quotient of its
-arguments.  The numeric arguments are first converted to a common
-type.  Plain or long integer division yields an integer of the same
-type; the result is that of mathematical division with the `floor'
-function applied to the result.  Division by zero raises the
-\verb@ZeroDivisionError@ exception.
-\exindex{ZeroDivisionError}
-\index{division}
-
-The \verb@"%"@ (modulo) operator yields the remainder from the
-division of the first argument by the second.  The numeric arguments
-are first converted to a common type.  A zero right argument raises
-the \verb@ZeroDivisionError@ exception.  The arguments may be floating
-point numbers, e.g. \verb@3.14 % 0.7@ equals \verb@0.34@.  The modulo
-operator always yields a result with the same sign as its second
-operand (or zero); the absolute value of the result is strictly
-smaller than the second operand.
-\index{modulo}
-
-The integer division and modulo operators are connected by the
-following identity: \verb@x == (x/y)*y + (x%y)@.  Integer division and
-modulo are also connected with the built-in function \verb@divmod()@:
-\verb@divmod(x, y) == (x/y, x%y)@.  These identities don't hold for
-floating point numbers; there a similar identity holds where
-\verb@x/y@ is replaced by \verb@floor(x/y)@).
-
-The \verb@"+"@ (addition) operator yields the sum of its arguments.
-The arguments must either both be numbers, or both sequences of the
-same type.  In the former case, the numbers are converted to a common
-type and then added together.  In the latter case, the sequences are
-concatenated.
-\index{addition}
-
-The \verb@"-"@ (subtraction) operator yields the difference of its
-arguments.  The numeric arguments are first converted to a common
-type.
-\index{subtraction}
-
-\section{Shifting operations}
-\indexii{shifting}{operation}
-
-The shifting operations have lower priority than the arithmetic
-operations:
-
-\begin{verbatim}
-shift_expr:     a_expr | shift_expr ( "<<" | ">>" ) a_expr
-\end{verbatim}
-
-These operators accept plain or long integers as arguments.  The
-arguments are converted to a common type.  They shift the first
-argument to the left or right by the number of bits given by the
-second argument.
-
-A right shift by \var{n} bits is defined as division by
-\code{pow(2,\var{n})}.  A left shift by \var{n} bits is defined as
-multiplication with \code{pow(2,\var{n})}; for plain integers there is
-no overflow check so this drops bits and flips the sign if the result
-is not less than \code{pow(2,31)} in absolute value.
-
-Negative shift counts raise a \verb@ValueError@ exception.
-\exindex{ValueError}
-
-\section{Binary bit-wise operations}
-\indexiii{binary}{bit-wise}{operation}
-
-Each of the three bitwise operations has a different priority level:
-
-\begin{verbatim}
-and_expr:       shift_expr | and_expr "&" shift_expr
-xor_expr:       and_expr | xor_expr "^" and_expr
-or_expr:       xor_expr | or_expr "|" xor_expr
-\end{verbatim}
-
-The \verb@"&"@ operator yields the bitwise AND of its arguments, which
-must be plain or long integers.  The arguments are converted to a
-common type.
-\indexii{bit-wise}{and}
-
-The \verb@"^"@ operator yields the bitwise XOR (exclusive OR) of its
-arguments, which must be plain or long integers.  The arguments are
-converted to a common type.
-\indexii{bit-wise}{xor}
-\indexii{exclusive}{or}
-
-The \verb@"|"@ operator yields the bitwise (inclusive) OR of its
-arguments, which must be plain or long integers.  The arguments are
-converted to a common type.
-\indexii{bit-wise}{or}
-\indexii{inclusive}{or}
-
-\section{Comparisons}
-\index{comparison}
-
-Contrary to C, all comparison operations in Python have the same
-priority, which is lower than that of any arithmetic, shifting or
-bitwise operation.  Also contrary to C, expressions like
-\verb@a < b < c@ have the interpretation that is conventional in
-mathematics:
-\index{C}
-
-\begin{verbatim}
-comparison:     or_expr (comp_operator or_expr)*
-comp_operator:  "<"|">"|"=="|">="|"<="|"<>"|"!="|"is" ["not"]|["not"] "in"
-\end{verbatim}
-
-Comparisons yield integer values: 1 for true, 0 for false.
-
-Comparisons can be chained arbitrarily, e.g. \code{x < y <= z} is
-equivalent to \code{x < y and y <= z}, except that \code{y} is
-evaluated only once (but in both cases \code{z} is not evaluated at all
-when \code{x < y} is found to be false).
-\indexii{chaining}{comparisons}
-
-Formally, if \var{a}, \var{b}, \var{c}, \ldots, \var{y}, \var{z} are
-expressions and \var{opa}, \var{opb}, \ldots, \var{opy} are comparison
-operators, then \var{a opa b opb c} \ldots \var{y opy z} is equivalent
-to \var{a opa b} \code{and} \var{b opb c} \code{and} \ldots \code{and}
-\var{y opy z}, except that each expression is evaluated at most once.
-
-Note that \var{a opa b opb c} doesn't imply any kind of comparison
-between \var{a} and \var{c}, so that e.g.\ \code{x < y > z} is
-perfectly legal (though perhaps not pretty).
-
-The forms \verb@<>@ and \verb@!=@ are equivalent; for consistency with
-C, \verb@!=@ is preferred; where \verb@!=@ is mentioned below
-\verb@<>@ is also implied.
-
-The operators {\tt "<", ">", "==", ">=", "<="}, and {\tt "!="} compare
-the values of two objects.  The objects needn't have the same type.
-If both are numbers, they are coverted to a common type.  Otherwise,
-objects of different types {\em always} compare unequal, and are
-ordered consistently but arbitrarily.
-
-(This unusual definition of comparison is done to simplify the
-definition of operations like sorting and the \verb@in@ and
-\verb@not@ \verb@in@ operators.)
-
-Comparison of objects of the same type depends on the type:
-
-\begin{itemize}
-
-\item
-Numbers are compared arithmetically.
-
-\item
-Strings are compared lexicographically using the numeric equivalents
-(the result of the built-in function \verb@ord@) of their characters.
-
-\item
-Tuples and lists are compared lexicographically using comparison of
-corresponding items.
-
-\item
-Mappings (dictionaries) are compared through lexicographic
-comparison of their sorted (key, value) lists.%
-\footnote{This is expensive since it requires sorting the keys first,
-but about the only sensible definition.  An earlier version of Python
-compared dictionaries by identity only, but this caused surprises
-because people expected to be able to test a dictionary for emptiness
-by comparing it to {\tt \{\}}.}
-
-\item
-Most other types compare unequal unless they are the same object;
-the choice whether one object is considered smaller or larger than
-another one is made arbitrarily but consistently within one
-execution of a program.
-
-\end{itemize}
-
-The operators \verb@in@ and \verb@not in@ test for sequence
-membership: if \var{y} is a sequence, \code{\var{x} in \var{y}} is
-true if and only if there exists an index \var{i} such that
-\code{\var{x} = \var{y}[\var{i}]}.
-\code{\var{x} not in \var{y}} yields the inverse truth value.  The
-exception \verb@TypeError@ is raised when \var{y} is not a sequence,
-or when \var{y} is a string and \var{x} is not a string of length one.%
-\footnote{The latter restriction is sometimes a nuisance.}
-\opindex{in}
-\opindex{not in}
-\indexii{membership}{test}
-\obindex{sequence}
-
-The operators \verb@is@ and \verb@is not@ test for object identity:
-\var{x} \code{is} \var{y} is true if and only if \var{x} and \var{y}
-are the same object.  \var{x} \code{is not} \var{y} yields the inverse
-truth value.
-\opindex{is}
-\opindex{is not}
-\indexii{identity}{test}
-
-\section{Boolean operations} \label{Booleans}
-\indexii{Boolean}{operation}
-
-Boolean operations have the lowest priority of all Python operations:
-
-\begin{verbatim}
-condition:      or_test | lambda_form
-or_test:        and_test | or_test "or" and_test
-and_test:       not_test | and_test "and" not_test
-not_test:       comparison | "not" not_test
-lambda_form:	"lambda" [parameter_list]: condition
-\end{verbatim}
-
-In the context of Boolean operations, and also when conditions are
-used by control flow statements, the following values are interpreted
-as false: \verb@None@, numeric zero of all types, empty sequences
-(strings, tuples and lists), and empty mappings (dictionaries).  All
-other values are interpreted as true.
-
-The operator \verb@not@ yields 1 if its argument is false, 0 otherwise.
-\opindex{not}
-
-The condition \var{x} \verb@and@ \var{y} first evaluates \var{x}; if
-\var{x} is false, its value is returned; otherwise, \var{y} is
-evaluated and the resulting value is returned.
-\opindex{and}
-
-The condition \var{x} \verb@or@ \var{y} first evaluates \var{x}; if
-\var{x} is true, its value is returned; otherwise, \var{y} is
-evaluated and the resulting value is returned.
-\opindex{or}
-
-(Note that \verb@and@ and \verb@or@ do not restrict the value and type
-they return to 0 and 1, but rather return the last evaluated argument.
-This is sometimes useful, e.g. if \verb@s@ is a string that should be
-replaced by a default value if it is empty, the expression
-\verb@s or 'foo'@ yields the desired value.  Because \verb@not@ has to
-invent a value anyway, it does not bother to return a value of the
-same type as its argument, so e.g. \verb@not 'foo'@ yields \verb@0@,
-not \verb@''@.)
-
-Lambda forms (lambda expressions) have the same syntactic position as
-conditions.  They are a shorthand to create anonymous functions; the
-expression {\em {\tt lambda} arguments{\tt :} condition}
-yields a function object that behaves virtually identical to one
-defined with
-{\em {\tt def} name {\tt (}arguments{\tt ): return} condition}.
-See section \ref{function} for the syntax of
-parameter lists.  Note that functions created with lambda forms cannot
-contain statements.
-\label{lambda}
-\indexii{lambda}{expression}
-\indexii{lambda}{form}
-\indexii{anonmymous}{function}
-
-\section{Expression lists and condition lists}
-\indexii{expression}{list}
-\indexii{condition}{list}
-
-\begin{verbatim}
-expression_list:      or_expr ("," or_expr)* [","]
-condintion_list:      condition ("," condition)* [","]
-\end{verbatim}
-
-The only difference between expression lists and condition lists is
-the lowest priority of operators that can be used in them without
-being enclosed in parentheses; condition lists allow all operators,
-while expression lists don't allow comparisons and Boolean operators
-(they do allow bitwise and shift operators though).
-
-Expression lists are used in expression statements and assignments;
-condition lists are used everywhere else where a list of
-comma-separated values is required.
-
-An expression (condition) list containing at least one comma yields a
-tuple.  The length of the tuple is the number of expressions
-(conditions) in the list.  The expressions (conditions) are evaluated
-from left to right.  (Condition lists are used syntactically is a few
-places where no tuple is constructed but a list of values is needed
-nevertheless.)
-\obindex{tuple}
-
-The trailing comma is required only to create a single tuple (a.k.a. a
-{\em singleton}); it is optional in all other cases.  A single
-expression (condition) without a trailing comma doesn't create a
-tuple, but rather yields the value of that expression (condition).
-\indexii{trailing}{comma}
-
-(To create an empty tuple, use an empty pair of parentheses:
-\verb@()@.)
-
-\section{Summary}
-
-The following table summarizes the operator precedences in Python,
-from lowest precedence (least binding) to highest precedence (most
-binding).  Operators in the same box have the same precedence.  Unless
-the syntax is explicitly given, operators are binary.  Operators in
-the same box group left to right (except for comparisons, which
-chain from left to right --- see above).
-
-\begin{center}
-\begin{tabular}{|c|c|}
-\hline
-\code{or} & Boolean OR \\
-\hline
-\code{and} & Boolean AND \\
-\hline
-\code{not} \var{x} & Boolean NOT \\
-\hline
-\code{in}, \code{not} \code{in} & Membership tests \\
-\code{is}, \code{is} \code{not} & Identity tests \\
-\code{<}, \code{<=}, \code{>}, \code{>=}, \code{<>}, \code{!=}, \code{=} &
-	Comparisons \\
-\hline
-\code{|} & Bitwise OR \\
-\hline
-\code{\^} & Bitwise XOR \\
-\hline
-\code{\&} & Bitwise AND \\
-\hline
-\code{<<}, \code{>>} & Shifts \\
-\hline
-\code{+}, \code{-} & Addition and subtraction \\
-\hline
-\code{*}, \code{/}, \code{\%} & Multiplication, division, remainder \\
-\hline
-\code{+\var{x}}, \code{-\var{x}} & Positive, negative \\
-\code{\~\var{x}} & Bitwise not \\
-\hline
-\code{\var{x}.\var{attribute}} & Attribute reference \\
-\code{\var{x}[\var{index}]} &  Subscription \\
-\code{\var{x}[\var{index}:\var{index}]} &  Slicing \\
-\code{\var{f}(\var{arguments}...)} & Function call \\
-\hline
-\code{(\var{expressions}\ldots)} & Binding or tuple display \\
-\code{[\var{expressions}\ldots]} & List display \\
-\code{\{\var{key}:\var{datum}\ldots\}} & Dictionary display \\
-\code{`\var{expression}\ldots`} & String conversion \\
-\hline
-\end{tabular}
-\end{center}
diff --git a/Doc/ref/ref6.tex b/Doc/ref/ref6.tex
deleted file mode 100644
index 5bd468c..0000000
--- a/Doc/ref/ref6.tex
+++ /dev/null
@@ -1,512 +0,0 @@
-\chapter{Simple statements}
-\indexii{simple}{statement}
-
-Simple statements are comprised within a single logical line.
-Several simple statements may occur on a single line separated
-by semicolons.  The syntax for simple statements is:
-
-\begin{verbatim}
-simple_stmt:    expression_stmt
-              | assignment_stmt
-              | pass_stmt
-              | del_stmt
-              | print_stmt
-              | return_stmt
-              | raise_stmt
-              | break_stmt
-              | continue_stmt
-              | import_stmt
-              | global_stmt
-              | exec_stmt
-\end{verbatim}
-
-\section{Expression statements}
-\indexii{expression}{statement}
-
-Expression statements are used (mostly interactively) to compute and
-write a value, or (usually) to call a procedure (a function that
-returns no meaningful result; in Python, procedures return the value
-\verb@None@):
-
-\begin{verbatim}
-expression_stmt: condition_list
-\end{verbatim}
-
-An expression statement evaluates the condition list (which may be a
-single condition).
-\indexii{expression}{list}
-
-In interactive mode, if the value is not \verb@None@, it is converted
-to a string using the rules for string conversions (expressions in
-reverse quotes), and the resulting string is written to standard
-output (see section \ref{print}) on a line by itself.
-(The exception for \verb@None@ is made so that procedure calls, which
-are syntactically equivalent to expressions, do not cause any output.)
-\ttindex{None}
-\indexii{string}{conversion}
-\index{output}
-\indexii{standard}{output}
-\indexii{writing}{values}
-\indexii{procedure}{call}
-
-\section{Assignment statements}
-\indexii{assignment}{statement}
-
-Assignment statements are used to (re)bind names to values and to
-modify attributes or items of mutable objects:
-\indexii{binding}{name}
-\indexii{rebinding}{name}
-\obindex{mutable}
-\indexii{attribute}{assignment}
-
-\begin{verbatim}
-assignment_stmt: (target_list "=")+ expression_list
-target_list:     target ("," target)* [","]
-target:          identifier | "(" target_list ")" | "[" target_list "]"
-               | attributeref | subscription | slicing
-\end{verbatim}
-
-(See section \ref{primaries} for the syntax definitions for the last
-three symbols.)
-
-An assignment statement evaluates the expression list (remember that
-this can be a single expression or a comma-separated list, the latter
-yielding a tuple) and assigns the single resulting object to each of
-the target lists, from left to right.
-\indexii{expression}{list}
-
-Assignment is defined recursively depending on the form of the target
-(list).  When a target is part of a mutable object (an attribute
-reference, subscription or slicing), the mutable object must
-ultimately perform the assignment and decide about its validity, and
-may raise an exception if the assignment is unacceptable.  The rules
-observed by various types and the exceptions raised are given with the
-definition of the object types (see section \ref{types}).
-\index{target}
-\indexii{target}{list}
-
-Assignment of an object to a target list is recursively defined as
-follows.
-\indexiii{target}{list}{assignment}
-
-\begin{itemize}
-\item
-If the target list is a single target: the object is assigned to that
-target.
-
-\item
-If the target list is a comma-separated list of targets: the object
-must be a tuple with the same number of items as the list contains
-targets, and the items are assigned, from left to right, to the
-corresponding targets.
-
-\end{itemize}
-
-Assignment of an object to a single target is recursively defined as
-follows.
-
-\begin{itemize} % nested
-
-\item
-If the target is an identifier (name):
-
-\begin{itemize}
-
-\item
-If the name does not occur in a \verb@global@ statement in the current
-code block: the name is bound to the object in the current local name
-space.
-\stindex{global}
-
-\item
-Otherwise: the name is bound to the object in the current global name
-space.
-
-\end{itemize} % nested
-
-The name is rebound if it was already bound.
-
-\item
-If the target is a target list enclosed in parentheses: the object is
-assigned to that target list as described above.
-
-\item
-If the target is a target list enclosed in square brackets: the object
-must be a list with the same number of items as the target list
-contains targets, and its items are assigned, from left to right, to
-the corresponding targets.
-
-\item
-If the target is an attribute reference: The primary expression in the
-reference is evaluated.  It should yield an object with assignable
-attributes; if this is not the case, \verb@TypeError@ is raised.  That
-object is then asked to assign the assigned object to the given
-attribute; if it cannot perform the assignment, it raises an exception
-(usually but not necessarily \verb@AttributeError@).
-\indexii{attribute}{assignment}
-
-\item
-If the target is a subscription: The primary expression in the
-reference is evaluated.  It should yield either a mutable sequence
-(list) object or a mapping (dictionary) object.  Next, the subscript
-expression is evaluated.
-\indexii{subscription}{assignment}
-\obindex{mutable}
-
-If the primary is a mutable sequence object (a list), the subscript
-must yield a plain integer.  If it is negative, the sequence's length
-is added to it.  The resulting value must be a nonnegative integer
-less than the sequence's length, and the sequence is asked to assign
-the assigned object to its item with that index.  If the index is out
-of range, \verb@IndexError@ is raised (assignment to a subscripted
-sequence cannot add new items to a list).
-\obindex{sequence}
-\obindex{list}
-
-If the primary is a mapping (dictionary) object, the subscript must
-have a type compatible with the mapping's key type, and the mapping is
-then asked to create a key/datum pair which maps the subscript to
-the assigned object.  This can either replace an existing key/value
-pair with the same key value, or insert a new key/value pair (if no
-key with the same value existed).
-\obindex{mapping}
-\obindex{dictionary}
-
-\item
-If the target is a slicing: The primary expression in the reference is
-evaluated.  It should yield a mutable sequence object (e.g. a list).  The
-assigned object should be a sequence object of the same type.  Next,
-the lower and upper bound expressions are evaluated, insofar they are
-present; defaults are zero and the sequence's length.  The bounds
-should evaluate to (small) integers.  If either bound is negative, the
-sequence's length is added to it.  The resulting bounds are clipped to
-lie between zero and the sequence's length, inclusive.  Finally, the
-sequence object is asked to replace the slice with the items of the
-assigned sequence.  The length of the slice may be different from the
-length of the assigned sequence, thus changing the length of the
-target sequence, if the object allows it.
-\indexii{slicing}{assignment}
-
-\end{itemize}
-	
-(In the current implementation, the syntax for targets is taken
-to be the same as for expressions, and invalid syntax is rejected
-during the code generation phase, causing less detailed error
-messages.)
-
-WARNING: Although the definition of assignment implies that overlaps
-between the left-hand side and the right-hand side are `safe' (e.g.
-\verb@a, b = b, a@ swaps two variables), overlaps within the
-collection of assigned-to variables are not safe!  For instance, the
-following program prints \code@[0, 2]@:
-
-\begin{verbatim}
-x = [0, 1]
-i = 0
-i, x[i] = 1, 2
-print x
-\end{verbatim}
-
-
-\section{The {\tt pass} statement}
-\stindex{pass}
-
-\begin{verbatim}
-pass_stmt:      "pass"
-\end{verbatim}
-
-\verb@pass@ is a null operation --- when it is executed, nothing
-happens.  It is useful as a placeholder when a statement is
-required syntactically, but no code needs to be executed, for example:
-\indexii{null}{operation}
-
-\begin{verbatim}
-def f(arg): pass    # a function that does nothing (yet)
-
-class C: pass       # a class with no methods (yet)
-\end{verbatim}
-
-\section{The {\tt del} statement}
-\stindex{del}
-
-\begin{verbatim}
-del_stmt:       "del" target_list
-\end{verbatim}
-
-Deletion is recursively defined very similar to the way assignment is
-defined. Rather that spelling it out in full details, here are some
-hints.
-\indexii{deletion}{target}
-\indexiii{deletion}{target}{list}
-
-Deletion of a target list recursively deletes each target, from left
-to right.
-
-Deletion of a name removes the binding of that name (which must exist)
-from the local or global name space, depending on whether the name
-occurs in a \verb@global@ statement in the same code block.
-\stindex{global}
-\indexii{unbinding}{name}
-
-Deletion of attribute references, subscriptions and slicings
-is passed to the primary object involved; deletion of a slicing
-is in general equivalent to assignment of an empty slice of the
-right type (but even this is determined by the sliced object).
-\indexii{attribute}{deletion}
-
-\section{The {\tt print} statement} \label{print}
-\stindex{print}
-
-\begin{verbatim}
-print_stmt:     "print" [ condition ("," condition)* [","] ]
-\end{verbatim}
-
-\verb@print@ evaluates each condition in turn and writes the resulting
-object to standard output (see below).  If an object is not a string,
-it is first converted to a string using the rules for string
-conversions.  The (resulting or original) string is then written.  A
-space is written before each object is (converted and) written, unless
-the output system believes it is positioned at the beginning of a
-line.  This is the case: (1) when no characters have yet been written
-to standard output; or (2) when the last character written to standard
-output is \verb/\n/; or (3) when the last write operation on standard
-output was not a \verb@print@ statement.  (In some cases it may be
-functional to write an empty string to standard output for this
-reason.)
-\index{output}
-\indexii{writing}{values}
-
-A \verb/"\n"/ character is written at the end, unless the \verb@print@
-statement ends with a comma.  This is the only action if the statement
-contains just the keyword \verb@print@.
-\indexii{trailing}{comma}
-\indexii{newline}{suppression}
-
-Standard output is defined as the file object named \verb@stdout@
-in the built-in module \verb@sys@.  If no such object exists,
-or if it is not a writable file, a \verb@RuntimeError@ exception is raised.
-(The original implementation attempts to write to the system's original
-standard output instead, but this is not safe, and should be fixed.)
-\indexii{standard}{output}
-\bimodindex{sys}
-\ttindex{stdout}
-\exindex{RuntimeError}
-
-\section{The {\tt return} statement}
-\stindex{return}
-
-\begin{verbatim}
-return_stmt:    "return" [condition_list]
-\end{verbatim}
-
-\verb@return@ may only occur syntactically nested in a function
-definition, not within a nested class definition.
-\indexii{function}{definition}
-\indexii{class}{definition}
-
-If a condition list is present, it is evaluated, else \verb@None@
-is substituted.
-
-\verb@return@ leaves the current function call with the condition
-list (or \verb@None@) as return value.
-
-When \verb@return@ passes control out of a \verb@try@ statement
-with a \verb@finally@ clause, that finally clause is executed
-before really leaving the function.
-\kwindex{finally}
-
-\section{The {\tt raise} statement}
-\stindex{raise}
-
-\begin{verbatim}
-raise_stmt:     "raise" condition ["," condition ["," condition]]
-\end{verbatim}
-
-\verb@raise@ evaluates its first condition, which must yield
-a string, class, or instance object.  If there is a second condition,
-this is evaluated, else \verb@None@ is substituted.  If the first
-condition is a class object, then the second condition must be an
-instance of that class or one of its derivatives.  If the first
-condition is an instance object, the second condition must be
-\verb@None@.
-\index{exception}
-\indexii{raising}{exception}
-
-If the first object is a class or string, it then raises the exception
-identified by the first object, with the second one (or \verb@None@)
-as its parameter.  If the first object is an instance, it raises the
-exception identified by the class of the object, with the instance as
-its parameter (and there should be no second object, or the second
-object should be \verb@None@).
-
-If a third object is present, and it it not \verb@None@, it should be
-a traceback object (see section \ref{traceback}), and it is
-substituted instead of the current location as the place where the
-exception occurred.  This is useful to re-raise an exception
-transparently in an except clause.
-\obindex{traceback}
-
-\section{The {\tt break} statement}
-\stindex{break}
-
-\begin{verbatim}
-break_stmt:     "break"
-\end{verbatim}
-
-\verb@break@ may only occur syntactically nested in a \verb@for@
-or \verb@while@ loop, but not nested in a function or class definition
-within that loop.
-\stindex{for}
-\stindex{while}
-\indexii{loop}{statement}
-
-It terminates the nearest enclosing loop, skipping the optional
-\verb@else@ clause if the loop has one.
-\kwindex{else}
-
-If a \verb@for@ loop is terminated by \verb@break@, the loop control
-target keeps its current value.
-\indexii{loop control}{target}
-
-When \verb@break@ passes control out of a \verb@try@ statement
-with a \verb@finally@ clause, that finally clause is executed
-before really leaving the loop.
-\kwindex{finally}
-
-\section{The {\tt continue} statement}
-\stindex{continue}
-
-\begin{verbatim}
-continue_stmt:  "continue"
-\end{verbatim}
-
-\verb@continue@ may only occur syntactically nested in a \verb@for@ or
-\verb@while@ loop, but not nested in a function or class definition or
-\verb@try@ statement within that loop.\footnote{Except that it may
-currently occur within an {\tt except} clause.}
-\stindex{for}
-\stindex{while}
-\indexii{loop}{statement}
-\kwindex{finally}
-
-It continues with the next cycle of the nearest enclosing loop.
-
-\section{The {\tt import} statement} \label{import}
-\stindex{import}
-
-\begin{verbatim}
-import_stmt:    "import" identifier ("," identifier)*
-              | "from" identifier "import" identifier ("," identifier)*
-              | "from" identifier "import" "*"
-\end{verbatim}
-
-Import statements are executed in two steps: (1) find a module, and
-initialize it if necessary; (2) define a name or names in the local
-name space (of the scope where the \verb@import@ statement occurs).
-The first form (without \verb@from@) repeats these steps for each
-identifier in the list, the \verb@from@ form performs them once, with
-the first identifier specifying the module name.
-\indexii{importing}{module}
-\indexii{name}{binding}
-\kwindex{from}
-
-The system maintains a table of modules that have been initialized,
-indexed by module name.  (The current implementation makes this table
-accessible as \verb@sys.modules@.)  When a module name is found in
-this table, step (1) is finished.  If not, a search for a module
-definition is started.  This first looks for a built-in module
-definition, and if no built-in module if the given name is found, it
-searches a user-specified list of directories for a file whose name is
-the module name with extension \verb@".py"@.  (The current
-implementation uses the list of strings \verb@sys.path@ as the search
-path; it is initialized from the shell environment variable
-\verb@$PYTHONPATH@, with an installation-dependent default.)
-\ttindex{modules}
-\ttindex{sys.modules}
-\indexii{module}{name}
-\indexii{built-in}{module}
-\indexii{user-defined}{module}
-\bimodindex{sys}
-\ttindex{path}
-\ttindex{sys.path}
-\indexii{filename}{extension}
-
-If a built-in module is found, its built-in initialization code is
-executed and step (1) is finished.  If no matching file is found,
-\verb@ImportError@ is raised.  If a file is found, it is parsed,
-yielding an executable code block.  If a syntax error occurs,
-\verb@SyntaxError@ is raised.  Otherwise, an empty module of the given
-name is created and inserted in the module table, and then the code
-block is executed in the context of this module.  Exceptions during
-this execution terminate step (1).
-\indexii{module}{initialization}
-\exindex{SyntaxError}
-\exindex{ImportError}
-\index{code block}
-
-When step (1) finishes without raising an exception, step (2) can
-begin.
-
-The first form of \verb@import@ statement binds the module name in the
-local name space to the module object, and then goes on to import the
-next identifier, if any.  The \verb@from@ from does not bind the
-module name: it goes through the list of identifiers, looks each one
-of them up in the module found in step (1), and binds the name in the
-local name space to the object thus found.  If a name is not found,
-\verb@ImportError@ is raised.  If the list of identifiers is replaced
-by a star (\verb@*@), all names defined in the module are bound,
-except those beginning with an underscore(\verb@_@).
-\indexii{name}{binding}
-\exindex{ImportError}
-
-Names bound by import statements may not occur in \verb@global@
-statements in the same scope.
-\stindex{global}
-
-The \verb@from@ form with \verb@*@ may only occur in a module scope.
-\kwindex{from}
-\ttindex{from ... import *}
-
-(The current implementation does not enforce the latter two
-restrictions, but programs should not abuse this freedom, as future
-implementations may enforce them or silently change the meaning of the
-program.)
-
-\section{The {\tt global} statement} \label{global}
-\stindex{global}
-
-\begin{verbatim}
-global_stmt:    "global" identifier ("," identifier)*
-\end{verbatim}
-
-The \verb@global@ statement is a declaration which holds for the
-entire current code block.  It means that the listed identifiers are to be
-interpreted as globals.  While {\em using} global names is automatic
-if they are not defined in the local scope, {\em assigning} to global
-names would be impossible without \verb@global@.
-\indexiii{global}{name}{binding}
-
-Names listed in a \verb@global@ statement must not be used in the same
-code block before that \verb@global@ statement is executed.
-
-Names listed in a \verb@global@ statement must not be defined as formal
-parameters or in a \verb@for@ loop control target, \verb@class@
-definition, function definition, or \verb@import@ statement.
-
-(The current implementation does not enforce the latter two
-restrictions, but programs should not abuse this freedom, as future
-implementations may enforce them or silently change the meaning of the
-program.)
-
-Note: the \verb@global@ is a directive to the parser.  Therefore, it
-applies only to code parsed at the same time as the \verb@global@
-statement.  In particular, a \verb@global@ statement contained in an
-\verb@exec@ statement does not affect the code block {\em containing}
-the \verb@exec@ statement, and code contained in an \verb@exec@
-statement is unaffected by \verb@global@ statements in the code
-containing the \verb@exec@ statement.  The same applies to the
-\verb@eval()@, \verb@execfie()@ and \verb@compile()@ functions.
-\stindex{exec}
-\ttindex{eval}
-\ttindex{execfile}
-\ttindex{compile}
diff --git a/Doc/ref/ref7.tex b/Doc/ref/ref7.tex
deleted file mode 100644
index 9bce121..0000000
--- a/Doc/ref/ref7.tex
+++ /dev/null
@@ -1,391 +0,0 @@
-\chapter{Compound statements}
-\indexii{compound}{statement}
-
-Compound statements contain (groups of) other statements; they affect
-or control the execution of those other statements in some way.  In
-general, compound statements span multiple lines, although in simple
-incarnations a whole compound statement may be contained in one line.
-
-The \verb@if@, \verb@while@ and \verb@for@ statements implement
-traditional control flow constructs.  \verb@try@ specifies exception
-handlers and/or cleanup code for a group of statements.  Function and
-class definitions are also syntactically compound statements.
-
-Compound statements consist of one or more `clauses'.  A clause
-consists of a header and a `suite'.  The clause headers of a
-particular compound statement are all at the same indentation level.
-Each clause header begins with a uniquely identifying keyword and ends
-with a colon.  A suite is a group of statements controlled by a
-clause.  A suite can be one or more semicolon-separated simple
-statements on the same line as the header, following the header's
-colon, or it can be one or more indented statements on subsequent
-lines.  Only the latter form of suite can contain nested compound
-statements; the following is illegal, mostly because it wouldn't be
-clear to which \verb@if@ clause a following \verb@else@ clause would
-belong:
-\index{clause}
-\index{suite}
-
-\begin{verbatim}
-if test1: if test2: print x
-\end{verbatim}
-
-Also note that the semicolon binds tighter than the colon in this
-context, so that in the following example, either all or none of the
-\verb@print@ statements are executed:
-
-\begin{verbatim}
-if x < y < z: print x; print y; print z
-\end{verbatim}
-
-Summarizing:
-
-\begin{verbatim}
-compound_stmt:  if_stmt | while_stmt | for_stmt
-              | try_stmt | funcdef | classdef
-suite:          stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
-statement:      stmt_list NEWLINE | compound_stmt
-stmt_list:      simple_stmt (";" simple_stmt)* [";"]
-\end{verbatim}
-
-Note that statements always end in a \verb@NEWLINE@ possibly followed
-by a \verb@DEDENT@.
-\index{NEWLINE token}
-\index{DEDENT token}
-
-Also note that optional continuation clauses always begin with a
-keyword that cannot start a statement, thus there are no ambiguities
-(the `dangling \verb@else@' problem is solved in Python by requiring
-nested \verb@if@ statements to be indented).
-\indexii{dangling}{else}
-
-The formatting of the grammar rules in the following sections places
-each clause on a separate line for clarity.
-
-\section{The {\tt if} statement}
-\stindex{if}
-
-The \verb@if@ statement is used for conditional execution:
-
-\begin{verbatim}
-if_stmt:        "if" condition ":" suite
-               ("elif" condition ":" suite)*
-               ["else" ":" suite]
-\end{verbatim}
-
-It selects exactly one of the suites by evaluating the conditions one
-by one until one is found to be true (see section \ref{Booleans} for
-the definition of true and false); then that suite is executed (and no
-other part of the \verb@if@ statement is executed or evaluated).  If
-all conditions are false, the suite of the \verb@else@ clause, if
-present, is executed.
-\kwindex{elif}
-\kwindex{else}
-
-\section{The {\tt while} statement}
-\stindex{while}
-\indexii{loop}{statement}
-
-The \verb@while@ statement is used for repeated execution as long as a
-condition is true:
-
-\begin{verbatim}
-while_stmt:     "while" condition ":" suite
-               ["else" ":" suite]
-\end{verbatim}
-
-This repeatedly tests the condition and, if it is true, executes the
-first suite; if the condition is false (which may be the first time it
-is tested) the suite of the \verb@else@ clause, if present, is
-executed and the loop terminates.
-\kwindex{else}
-
-A \verb@break@ statement executed in the first suite terminates the
-loop without executing the \verb@else@ clause's suite.  A
-\verb@continue@ statement executed in the first suite skips the rest
-of the suite and goes back to testing the condition.
-\stindex{break}
-\stindex{continue}
-
-\section{The {\tt for} statement}
-\stindex{for}
-\indexii{loop}{statement}
-
-The \verb@for@ statement is used to iterate over the elements of a
-sequence (string, tuple or list):
-\obindex{sequence}
-
-\begin{verbatim}
-for_stmt:       "for" target_list "in" condition_list ":" suite
-               ["else" ":" suite]
-\end{verbatim}
-
-The condition list is evaluated once; it should yield a sequence.  The
-suite is then executed once for each item in the sequence, in the
-order of ascending indices.  Each item in turn is assigned to the
-target list using the standard rules for assignments, and then the
-suite is executed.  When the items are exhausted (which is immediately
-when the sequence is empty), the suite in the \verb@else@ clause, if
-present, is executed, and the loop terminates.
-\kwindex{in}
-\kwindex{else}
-\indexii{target}{list}
-
-A \verb@break@ statement executed in the first suite terminates the
-loop without executing the \verb@else@ clause's suite.  A
-\verb@continue@ statement executed in the first suite skips the rest
-of the suite and continues with the next item, or with the \verb@else@
-clause if there was no next item.
-\stindex{break}
-\stindex{continue}
-
-The suite may assign to the variable(s) in the target list; this does
-not affect the next item assigned to it.
-
-The target list is not deleted when the loop is finished, but if the
-sequence is empty, it will not have been assigned to at all by the
-loop.
-
-Hint: the built-in function \verb@range()@ returns a sequence of
-integers suitable to emulate the effect of Pascal's
-\verb@for i := a to b do@;
-e.g. \verb@range(3)@ returns the list \verb@[0, 1, 2]@.
-\bifuncindex{range}
-\index{Pascal}
-
-{\bf Warning:} There is a subtlety when the sequence is being modified
-by the loop (this can only occur for mutable sequences, i.e. lists).
-An internal counter is used to keep track of which item is used next,
-and this is incremented on each iteration.  When this counter has
-reached the length of the sequence the loop terminates.  This means that
-if the suite deletes the current (or a previous) item from the
-sequence, the next item will be skipped (since it gets the index of
-the current item which has already been treated).  Likewise, if the
-suite inserts an item in the sequence before the current item, the
-current item will be treated again the next time through the loop.
-This can lead to nasty bugs that can be avoided by making a temporary
-copy using a slice of the whole sequence, e.g.
-\index{loop!over mutable sequence}
-\index{mutable sequence!loop over}
-
-\begin{verbatim}
-for x in a[:]:
-    if x < 0: a.remove(x)
-\end{verbatim}
-
-\section{The {\tt try} statement} \label{try}
-\stindex{try}
-
-The \verb@try@ statement specifies exception handlers and/or cleanup
-code for a group of statements:
-
-\begin{verbatim}
-try_stmt:       try_exc_stmt | try_fin_stmt
-try_exc_stmt:   "try" ":" suite
-               ("except" [condition ["," target]] ":" suite)+
-               ["else" ":" suite]
-try_fin_stmt:   "try" ":" suite
-               "finally" ":" suite
-\end{verbatim}
-
-There are two forms of \verb@try@ statement: \verb@try...except@ and
-\verb@try...finally@.  These forms cannot be mixed.
-
-The \verb@try...except@ form specifies one or more exception handlers
-(the \verb@except@ clauses).  When no exception occurs in the
-\verb@try@ clause, no exception handler is executed.  When an
-exception occurs in the \verb@try@ suite, a search for an exception
-handler is started.  This inspects the except clauses in turn until
-one is found that matches the exception.  A condition-less except
-clause, if present, must be last; it matches any exception.  For an
-except clause with a condition, that condition is evaluated, and the
-clause matches the exception if the resulting object is ``compatible''
-with the exception.  An object is compatible with an exception if it
-is either the object that identifies the exception, or (for exceptions
-that are classes) it is a base class of the exception, or it is a
-tuple containing an item that is compatible with the exception.  Note
-that the object identities must match, i.e. it must be the same
-object, not just an object with the same value.
-\kwindex{except}
-
-If no except clause matches the exception, the search for an exception
-handler continues in the surrounding code and on the invocation stack.
-
-If the evaluation of a condition in the header of an except clause
-raises an exception, the original search for a handler is cancelled
-and a search starts for the new exception in the surrounding code and
-on the call stack (it is treated as if the entire \verb@try@ statement
-raised the exception).
-
-When a matching except clause is found, the exception's parameter is
-assigned to the target specified in that except clause, if present,
-and the except clause's suite is executed.  When the end of this suite
-is reached, execution continues normally after the entire try
-statement.  (This means that if two nested handlers exist for the same
-exception, and the exception occurs in the try clause of the inner
-handler, the outer handler will not handle the exception.)
-
-Before an except clause's suite is executed, details about the
-exception are assigned to three variables in the \verb@sys@ module:
-\verb@sys.exc_type@ receives the object identifying the exception;
-\verb@sys.exc_value@ receives the exception's parameter;
-\verb@sys.exc_traceback@ receives a traceback object (see section
-\ref{traceback}) identifying the point in the program where the
-exception occurred.
-\bimodindex{sys}
-\ttindex{exc_type}
-\ttindex{exc_value}
-\ttindex{exc_traceback}
-\obindex{traceback}
-
-The optional \verb@else@ clause is executed when no exception occurs
-in the \verb@try@ clause.  Exceptions in the \verb@else@ clause are
-not handled by the preceding \verb@except@ clauses.
-\kwindex{else}
-
-The \verb@try...finally@ form specifies a `cleanup' handler.  The
-\verb@try@ clause is executed.  When no exception occurs, the
-\verb@finally@ clause is executed.  When an exception occurs in the
-\verb@try@ clause, the exception is temporarily saved, the
-\verb@finally@ clause is executed, and then the saved exception is
-re-raised.  If the \verb@finally@ clause raises another exception or
-executes a \verb@return@, \verb@break@ or \verb@continue@ statement,
-the saved exception is lost.
-\kwindex{finally}
-
-When a \verb@return@ or \verb@break@ statement is executed in the
-\verb@try@ suite of a \verb@try...finally@ statement, the
-\verb@finally@ clause is also executed `on the way out'.  A
-\verb@continue@ statement is illegal in the \verb@try@ clause.  (The
-reason is a problem with the current implementation --- this
-restriction may be lifted in the future).
-\stindex{return}
-\stindex{break}
-\stindex{continue}
-
-\section{Function definitions} \label{function}
-\indexii{function}{definition}
-
-A function definition defines a user-defined function object (see
-section \ref{types}):\footnote{The new syntax to receive arbitrary
-keyword arguments is not yet documented in this manual.  See chapter
-12 of the Tutorial.}
-\obindex{user-defined function}
-\obindex{function}
-
-\begin{verbatim}
-funcdef:        "def" funcname "(" [parameter_list] ")" ":" suite
-parameter_list: (defparameter ",")* ("*" identifier [, "**" identifier] 
-                                    | "**" identifier 
-                                    | defparameter [","])
-defparameter:   parameter ["=" condition]
-sublist:        parameter ("," parameter)* [","]
-parameter:      identifier | "(" sublist ")"
-funcname:       identifier
-\end{verbatim}
-
-A function definition is an executable statement.  Its execution binds
-the function name in the current local name space to a function object
-(a wrapper around the executable code for the function).  This
-function object contains a reference to the current global name space
-as the global name space to be used when the function is called.
-\indexii{function}{name}
-\indexii{name}{binding}
-
-The function definition does not execute the function body; this gets
-executed only when the function is called.
-
-When one or more top-level parameters have the form {\em parameter =
-condition}, the function is said to have ``default parameter values''.
-Default parameter values are evaluated when the function definition is
-executed.  For a parameter with a default value, the correponding
-argument may be omitted from a call, in which case the parameter's
-default value is substituted.  If a parameter has a default value, all
-following parameters must also have a default value --- this is a
-syntactic restriction that is not expressed by the grammar.%
-\footnote{Currently this is not checked; instead,
-{\tt def f(a=1,b)} is interpreted as {\tt def f(a=1,b=None)}.}
-\indexiii{default}{parameter}{value}
-
-Function call semantics are described in section \ref{calls}.  When a
-user-defined function is called, first missing arguments for which a
-default value exists are supplied; then the arguments (a.k.a. actual
-parameters) are bound to the (formal) parameters, as follows:
-\indexii{function}{call}
-\indexiii{user-defined}{function}{call}
-\index{parameter}
-\index{argument}
-\indexii{parameter}{formal}
-\indexii{parameter}{actual}
-
-\begin{itemize}
-
-\item
-If there are no formal parameters, there must be no arguments.
-
-\item
-If the formal parameter list does not end in a star followed by an
-identifier, there must be exactly as many arguments as there are
-parameters in the formal parameter list (at the top level); the
-arguments are assigned to the formal parameters one by one.  Note that
-the presence or absence of a trailing comma at the top level in either
-the formal or the actual parameter list makes no difference.  The
-assignment to a formal parameter is performed as if the parameter
-occurs on the left hand side of an assignment statement whose right
-hand side's value is that of the argument.
-
-\item
-If the formal parameter list ends in a star followed by an identifier,
-preceded by zero or more comma-followed parameters, there must be at
-least as many arguments as there are parameters preceding the star.
-Call this number {\em N}.  The first {\em N} arguments are assigned to
-the corresponding formal parameters in the way descibed above.  A
-tuple containing the remaining arguments, if any, is then assigned to
-the identifier following the star.  This variable will always be a
-tuple: if there are no extra arguments, its value is \verb@()@, if
-there is just one extra argument, it is a singleton tuple.
-\indexii{variable length}{parameter list}
-
-\end{itemize}
-
-Note that the `variable length parameter list' feature only works at
-the top level of the parameter list; individual parameters use a model
-corresponding more closely to that of ordinary assignment.  While the
-latter model is generally preferable, because of the greater type
-safety it offers (wrong-sized tuples aren't silently mistreated),
-variable length parameter lists are a sufficiently accepted practice
-in most programming languages that a compromise has been worked out.
-(And anyway, assignment has no equivalent for empty argument lists.)
-
-It is also possible to create anonymous functions (functions not bound
-to a name), for immediate use in expressions.  This uses lambda forms,
-described in section \ref{lambda}.
-\indexii{lambda}{form}
-
-\section{Class definitions} \label{class}
-\indexii{class}{definition}
-
-A class definition defines a class object (see section \ref{types}):
-\obindex{class}
-
-\begin{verbatim}
-classdef:       "class" classname [inheritance] ":" suite
-inheritance:    "(" [condition_list] ")"
-classname:      identifier
-\end{verbatim}
-
-A class definition is an executable statement.  It first evaluates the
-inheritance list, if present.  Each item in the inheritance list
-should evaluate to a class object.  The class's suite is then executed
-in a new execution frame (see section \ref{execframes}), using a newly
-created local name space and the original global name space.
-(Usually, the suite contains only function definitions.)  When the
-class's suite finishes execution, its execution frame is discarded but
-its local name space is saved.  A class object is then created using
-the inheritance list for the base classes and the saved local name
-space for the attribute dictionary.  The class name is bound to this
-class object in the original local name space.
-\index{inheritance}
-\indexii{class}{name}
-\indexii{name}{binding}
-\indexii{execution}{frame}
diff --git a/Doc/ref/ref8.tex b/Doc/ref/ref8.tex
deleted file mode 100644
index a9e688a..0000000
--- a/Doc/ref/ref8.tex
+++ /dev/null
@@ -1,105 +0,0 @@
-\chapter{Top-level components}
-
-The Python interpreter can get its input from a number of sources:
-from a script passed to it as standard input or as program argument,
-typed in interactively, from a module source file, etc.  This chapter
-gives the syntax used in these cases.
-\index{interpreter}
-
-\section{Complete Python programs}
-\index{program}
-
-While a language specification need not prescribe how the language
-interpreter is invoked, it is useful to have a notion of a complete
-Python program.  A complete Python program is executed in a minimally
-initialized environment: all built-in and standard modules are
-available, but none have been initialized, except for \verb@sys@
-(various system services), \verb@__builtin__@ (built-in functions,
-exceptions and \verb@None@) and \verb@__main__@.  The latter is used
-to provide the local and global name space for execution of the
-complete program.
-\bimodindex{sys}
-\bimodindex{__main__}
-\bimodindex{__builtin__}
-
-The syntax for a complete Python program is that for file input,
-described in the next section.
-
-The interpreter may also be invoked in interactive mode; in this case,
-it does not read and execute a complete program but reads and executes
-one statement (possibly compound) at a time.  The initial environment
-is identical to that of a complete program; each statement is executed
-in the name space of \verb@__main__@.
-\index{interactive mode}
-\bimodindex{__main__}
-
-Under {\UNIX}, a complete program can be passed to the interpreter in
-three forms: with the {\bf -c} {\it string} command line option, as a
-file passed as the first command line argument, or as standard input.
-If the file or standard input is a tty device, the interpreter enters
-interactive mode; otherwise, it executes the file as a complete
-program.
-\index{UNIX}
-\index{command line}
-\index{standard input}
-
-\section{File input}
-
-All input read from non-interactive files has the same form:
-
-\begin{verbatim}
-file_input:     (NEWLINE | statement)*
-\end{verbatim}
-
-This syntax is used in the following situations:
-
-\begin{itemize}
-
-\item when parsing a complete Python program (from a file or from a string);
-
-\item when parsing a module;
-
-\item when parsing a string passed to the \verb@exec@ statement;
-
-\end{itemize}
-
-\section{Interactive input}
-
-Input in interactive mode is parsed using the following grammar:
-
-\begin{verbatim}
-interactive_input: [stmt_list] NEWLINE | compound_stmt NEWLINE
-\end{verbatim}
-
-Note that a (top-level) compound statement must be followed by a blank
-line in interactive mode; this is needed to help the parser detect the
-end of the input.
-
-\section{Expression input}
-\index{input}
-
-There are two forms of expression input.  Both ignore leading
-whitespace.
- 
-The string argument to \verb@eval()@ must have the following form:
-\bifuncindex{eval}
-
-\begin{verbatim}
-eval_input:     condition_list NEWLINE*
-\end{verbatim}
-
-The input line read by \verb@input()@ must have the following form:
-\bifuncindex{input}
-
-\begin{verbatim}
-input_input:    condition_list NEWLINE
-\end{verbatim}
-
-Note: to read `raw' input line without interpretation, you can use the
-built-in function \verb@raw_input()@  or the \verb@readline()@ method
-of file objects.
-\obindex{file}
-\index{input!raw}
-\index{raw input}
-\bifuncindex{raw_index}
-\ttindex{readline}
diff --git a/Doc/ref1.tex b/Doc/ref1.tex
deleted file mode 100644
index 30bfcce..0000000
--- a/Doc/ref1.tex
+++ /dev/null
@@ -1,81 +0,0 @@
-\chapter{Introduction}
-
-This reference manual describes the Python programming language.
-It is not intended as a tutorial.
-
-While I am trying to be as precise as possible, I chose to use English
-rather than formal specifications for everything except syntax and
-lexical analysis.  This should make the document more understandable
-to the average reader, but will leave room for ambiguities.
-Consequently, if you were coming from Mars and tried to re-implement
-Python from this document alone, you might have to guess things and in
-fact you would probably end up implementing quite a different language.
-On the other hand, if you are using
-Python and wonder what the precise rules about a particular area of
-the language are, you should definitely be able to find them here.
-
-It is dangerous to add too many implementation details to a language
-reference document --- the implementation may change, and other
-implementations of the same language may work differently.  On the
-other hand, there is currently only one Python implementation, and
-its particular quirks are sometimes worth being mentioned, especially
-where the implementation imposes additional limitations.  Therefore,
-you'll find short ``implementation notes'' sprinkled throughout the
-text.
-
-Every Python implementation comes with a number of built-in and
-standard modules.  These are not documented here, but in the separate
-{\em Python Library Reference} document.  A few built-in modules are
-mentioned when they interact in a significant way with the language
-definition.
-
-\section{Notation}
-
-The descriptions of lexical analysis and syntax use a modified BNF
-grammar notation.  This uses the following style of definition:
-\index{BNF}
-\index{grammar}
-\index{syntax}
-\index{notation}
-
-\begin{verbatim}
-name:           lc_letter (lc_letter | "_")*
-lc_letter:      "a"..."z"
-\end{verbatim}
-
-The first line says that a \verb@name@ is an \verb@lc_letter@ followed by
-a sequence of zero or more \verb@lc_letter@s and underscores.  An
-\verb@lc_letter@ in turn is any of the single characters `a' through `z'.
-(This rule is actually adhered to for the names defined in lexical and
-grammar rules in this document.)
-
-Each rule begins with a name (which is the name defined by the rule)
-and a colon.  A vertical bar (\verb@|@) is used to separate
-alternatives; it is the least binding operator in this notation.  A
-star (\verb@*@) means zero or more repetitions of the preceding item;
-likewise, a plus (\verb@+@) means one or more repetitions, and a
-phrase enclosed in square brackets (\verb@[ ]@) means zero or one
-occurrences (in other words, the enclosed phrase is optional).  The
-\verb@*@ and \verb@+@ operators bind as tightly as possible;
-parentheses are used for grouping.  Literal strings are enclosed in
-quotes.  White space is only meaningful to separate tokens.
-Rules are normally contained on a single line; rules with many
-alternatives may be formatted alternatively with each line after the
-first beginning with a vertical bar.
-
-In lexical definitions (as the example above), two more conventions
-are used: Two literal characters separated by three dots mean a choice
-of any single character in the given (inclusive) range of \ASCII{}
-characters.  A phrase between angular brackets (\verb@<...>@) gives an
-informal description of the symbol defined; e.g. this could be used
-to describe the notion of `control character' if needed.
-\index{lexical definitions}
-\index{ASCII}
-
-Even though the notation used is almost the same, there is a big
-difference between the meaning of lexical and syntactic definitions:
-a lexical definition operates on the individual characters of the
-input source, while a syntax definition operates on the stream of
-tokens generated by the lexical analysis.  All uses of BNF in the next
-chapter (``Lexical Analysis'') are lexical definitions; uses in
-subsequent chapters are syntactic definitions.
diff --git a/Doc/ref2.tex b/Doc/ref2.tex
deleted file mode 100644
index b093998..0000000
--- a/Doc/ref2.tex
+++ /dev/null
@@ -1,372 +0,0 @@
-\chapter{Lexical analysis}
-
-A Python program is read by a {\em parser}.  Input to the parser is a
-stream of {\em tokens}, generated by the {\em lexical analyzer}.  This
-chapter describes how the lexical analyzer breaks a file into tokens.
-\index{lexical analysis}
-\index{parser}
-\index{token}
-
-\section{Line structure}
-
-A Python program is divided in a number of logical lines.  The end of
-a logical line is represented by the token NEWLINE.  Statements cannot
-cross logical line boundaries except where NEWLINE is allowed by the
-syntax (e.g. between statements in compound statements).
-\index{line structure}
-\index{logical line}
-\index{NEWLINE token}
-
-\subsection{Comments}
-
-A comment starts with a hash character (\verb@#@) that is not part of
-a string literal, and ends at the end of the physical line.  A comment
-always signifies the end of the logical line.  Comments are ignored by
-the syntax.
-\index{comment}
-\index{logical line}
-\index{physical line}
-\index{hash character}
-
-\subsection{Explicit line joining}
-
-Two or more physical lines may be joined into logical lines using
-backslash characters (\verb/\/), as follows: when a physical line ends
-in a backslash that is not part of a string literal or comment, it is
-joined with the following forming a single logical line, deleting the
-backslash and the following end-of-line character.  For example:
-\index{physical line}
-\index{line joining}
-\index{line continuation}
-\index{backslash character}
-%
-\begin{verbatim}
-if 1900 < year < 2100 and 1 <= month <= 12 \
-   and 1 <= day <= 31 and 0 <= hour < 24 \
-   and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
-        return 1
-\end{verbatim}
-
-A line ending in a backslash cannot carry a comment; a backslash does
-not continue a comment (but it does continue a string literal, see
-below).
-
-\subsection{Implicit line joining}
-
-Expressions in parentheses, square brackets or curly braces can be
-split over more than one physical line without using backslashes.
-For example:
-
-\begin{verbatim}
-month_names = ['Januari', 'Februari', 'Maart',      # These are the
-               'April',   'Mei',      'Juni',       # Dutch names
-               'Juli',    'Augustus', 'September',  # for the months
-               'Oktober', 'November', 'December']   # of the year
-\end{verbatim}
-
-Implicitly continued lines can carry comments.  The indentation of the
-continuation lines is not important.  Blank continuation lines are
-allowed.
-
-\subsection{Blank lines}
-
-A logical line that contains only spaces, tabs, and possibly a
-comment, is ignored (i.e., no NEWLINE token is generated), except that
-during interactive input of statements, an entirely blank logical line
-terminates a multi-line statement.
-\index{blank line}
-
-\subsection{Indentation}
-
-Leading whitespace (spaces and tabs) at the beginning of a logical
-line is used to compute the indentation level of the line, which in
-turn is used to determine the grouping of statements.
-\index{indentation}
-\index{whitespace}
-\index{leading whitespace}
-\index{space}
-\index{tab}
-\index{grouping}
-\index{statement grouping}
-
-First, tabs are replaced (from left to right) by one to eight spaces
-such that the total number of characters up to there is a multiple of
-eight (this is intended to be the same rule as used by {\UNIX}).  The
-total number of spaces preceding the first non-blank character then
-determines the line's indentation.  Indentation cannot be split over
-multiple physical lines using backslashes.
-
-The indentation levels of consecutive lines are used to generate
-INDENT and DEDENT tokens, using a stack, as follows.
-\index{INDENT token}
-\index{DEDENT token}
-
-Before the first line of the file is read, a single zero is pushed on
-the stack; this will never be popped off again.  The numbers pushed on
-the stack will always be strictly increasing from bottom to top.  At
-the beginning of each logical line, the line's indentation level is
-compared to the top of the stack.  If it is equal, nothing happens.
-If it is larger, it is pushed on the stack, and one INDENT token is
-generated.  If it is smaller, it {\em must} be one of the numbers
-occurring on the stack; all numbers on the stack that are larger are
-popped off, and for each number popped off a DEDENT token is
-generated.  At the end of the file, a DEDENT token is generated for
-each number remaining on the stack that is larger than zero.
-
-Here is an example of a correctly (though confusingly) indented piece
-of Python code:
-
-\begin{verbatim}
-def perm(l):
-        # Compute the list of all permutations of l
-
-    if len(l) <= 1:
-                  return [l]
-    r = []
-    for i in range(len(l)):
-             s = l[:i] + l[i+1:]
-             p = perm(s)
-             for x in p:
-              r.append(l[i:i+1] + x)
-    return r
-\end{verbatim}
-
-The following example shows various indentation errors:
-
-\begin{verbatim}
-    def perm(l):                        # error: first line indented
-    for i in range(len(l)):             # error: not indented
-        s = l[:i] + l[i+1:]
-            p = perm(l[:i] + l[i+1:])   # error: unexpected indent
-            for x in p:
-                    r.append(l[i:i+1] + x)
-                return r                # error: inconsistent dedent
-\end{verbatim}
-
-(Actually, the first three errors are detected by the parser; only the
-last error is found by the lexical analyzer --- the indentation of
-\verb@return r@ does not match a level popped off the stack.)
-
-\section{Other tokens}
-
-Besides NEWLINE, INDENT and DEDENT, the following categories of tokens
-exist: identifiers, keywords, literals, operators, and delimiters.
-Spaces and tabs are not tokens, but serve to delimit tokens.  Where
-ambiguity exists, a token comprises the longest possible string that
-forms a legal token, when read from left to right.
-
-\section{Identifiers}
-
-Identifiers (also referred to as names) are described by the following
-lexical definitions:
-\index{identifier}
-\index{name}
-
-\begin{verbatim}
-identifier:     (letter|"_") (letter|digit|"_")*
-letter:         lowercase | uppercase
-lowercase:      "a"..."z"
-uppercase:      "A"..."Z"
-digit:          "0"..."9"
-\end{verbatim}
-
-Identifiers are unlimited in length.  Case is significant.
-
-\subsection{Keywords}
-
-The following identifiers are used as reserved words, or {\em
-keywords} of the language, and cannot be used as ordinary
-identifiers.  They must be spelled exactly as written here:
-\index{keyword}
-\index{reserved word}
-
-\begin{verbatim}
-and        elif       global     not        try       
-break      else       if         or         while     
-class      except     import     pass      
-continue   finally    in         print     
-def        for        is         raise     
-del        from       lambda     return    
-\end{verbatim}
-
-% When adding keywords, pipe it through keywords.py for reformatting
-
-\section{Literals} \label{literals}
-
-Literals are notations for constant values of some built-in types.
-\index{literal}
-\index{constant}
-
-\subsection{String literals}
-
-String literals are described by the following lexical definitions:
-\index{string literal}
-
-\begin{verbatim}
-stringliteral:   shortstring | longstring
-shortstring:     "'" shortstringitem* "'" | '"' shortstringitem* '"'
-longstring:      "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
-shortstringitem: shortstringchar | escapeseq
-longstringitem:  longstringchar | escapeseq
-shortstringchar: <any ASCII character except "\" or newline or the quote>
-longstringchar:  <any ASCII character except "\">
-escapeseq:       "\" <any ASCII character>
-\end{verbatim}
-\index{ASCII}
-
-In ``long strings'' (strings surrounded by sets of three quotes),
-unescaped newlines and quotes are allowed (and are retained), except
-that three unescaped quotes in a row terminate the string.  (A
-``quote'' is the character used to open the string, i.e. either
-\verb/'/ or \verb/"/.)
-
-Escape sequences in strings are interpreted according to rules similar
-to those used by Standard C.  The recognized escape sequences are:
-\index{physical line}
-\index{escape sequence}
-\index{Standard C}
-\index{C}
-
-\begin{center}
-\begin{tabular}{|l|l|}
-\hline
-\verb/\/{\em newline}	& Ignored \\
-\verb/\\/	& Backslash (\verb/\/) \\
-\verb/\'/	& Single quote (\verb/'/) \\
-\verb/\"/	& Double quote (\verb/"/) \\
-\verb/\a/	& \ASCII{} Bell (BEL) \\
-\verb/\b/	& \ASCII{} Backspace (BS) \\
-%\verb/\E/	& \ASCII{} Escape (ESC) \\
-\verb/\f/	& \ASCII{} Formfeed (FF) \\
-\verb/\n/	& \ASCII{} Linefeed (LF) \\
-\verb/\r/	& \ASCII{} Carriage Return (CR) \\
-\verb/\t/	& \ASCII{} Horizontal Tab (TAB) \\
-\verb/\v/	& \ASCII{} Vertical Tab (VT) \\
-\verb/\/{\em ooo}	& \ASCII{} character with octal value {\em ooo} \\
-\verb/\x/{\em xx...}	& \ASCII{} character with hex value {\em xx...} \\
-\hline
-\end{tabular}
-\end{center}
-\index{ASCII}
-
-In strict compatibility with Standard C, up to three octal digits are
-accepted, but an unlimited number of hex digits is taken to be part of
-the hex escape (and then the lower 8 bits of the resulting hex number
-are used in all current implementations...).
-
-All unrecognized escape sequences are left in the string unchanged,
-i.e., {\em the backslash is left in the string.}  (This behavior is
-useful when debugging: if an escape sequence is mistyped, the
-resulting output is more easily recognized as broken.  It also helps a
-great deal for string literals used as regular expressions or
-otherwise passed to other modules that do their own escape handling.)
-\index{unrecognized escape sequence}
-
-\subsection{Numeric literals}
-
-There are three types of numeric literals: plain integers, long
-integers, and floating point numbers.
-\index{number}
-\index{numeric literal}
-\index{integer literal}
-\index{plain integer literal}
-\index{long integer literal}
-\index{floating point literal}
-\index{hexadecimal literal}
-\index{octal literal}
-\index{decimal literal}
-
-Integer and long integer literals are described by the following
-lexical definitions:
-
-\begin{verbatim}
-longinteger:    integer ("l"|"L")
-integer:        decimalinteger | octinteger | hexinteger
-decimalinteger: nonzerodigit digit* | "0"
-octinteger:     "0" octdigit+
-hexinteger:     "0" ("x"|"X") hexdigit+
-
-nonzerodigit:   "1"..."9"
-octdigit:       "0"..."7"
-hexdigit:        digit|"a"..."f"|"A"..."F"
-\end{verbatim}
-
-Although both lower case `l' and upper case `L' are allowed as suffix
-for long integers, it is strongly recommended to always use `L', since
-the letter `l' looks too much like the digit `1'.
-
-Plain integer decimal literals must be at most 2147483647 (i.e., the
-largest positive integer, using 32-bit arithmetic).  Plain octal and
-hexadecimal literals may be as large as 4294967295, but values larger
-than 2147483647 are converted to a negative value by subtracting
-4294967296.  There is no limit for long integer literals apart from
-what can be stored in available memory.
-
-Some examples of plain and long integer literals:
-
-\begin{verbatim}
-7     2147483647                        0177    0x80000000
-3L    79228162514264337593543950336L    0377L   0x100000000L
-\end{verbatim}
-
-Floating point literals are described by the following lexical
-definitions:
-
-\begin{verbatim}
-floatnumber:    pointfloat | exponentfloat
-pointfloat:     [intpart] fraction | intpart "."
-exponentfloat:  (intpart | pointfloat) exponent
-intpart:        digit+
-fraction:       "." digit+
-exponent:       ("e"|"E") ["+"|"-"] digit+
-\end{verbatim}
-
-The allowed range of floating point literals is
-implementation-dependent.
-
-Some examples of floating point literals:
-
-\begin{verbatim}
-3.14    10.    .001    1e100    3.14e-10
-\end{verbatim}
-
-Note that numeric literals do not include a sign; a phrase like
-\verb@-1@ is actually an expression composed of the operator
-\verb@-@ and the literal \verb@1@.
-
-\section{Operators}
-
-The following tokens are operators:
-\index{operators}
-
-\begin{verbatim}
-+       -       *       /       %
-<<      >>      &       |       ^       ~
-<       ==      >       <=      <>      !=      >=
-\end{verbatim}
-
-The comparison operators \verb@<>@ and \verb@!=@ are alternate
-spellings of the same operator.
-
-\section{Delimiters}
-
-The following tokens serve as delimiters or otherwise have a special
-meaning:
-\index{delimiters}
-
-\begin{verbatim}
-(       )       [       ]       {       }
-,       :       .       "       `       '
-=	;
-\end{verbatim}
-
-The following printing \ASCII{} characters are not used in Python.  Their
-occurrence outside string literals and comments is an unconditional
-error:
-\index{ASCII}
-
-\begin{verbatim}
-@       $       ?
-\end{verbatim}
-
-They may be used by future versions of the language though!
diff --git a/Doc/ref3.tex b/Doc/ref3.tex
deleted file mode 100644
index ca3525a..0000000
--- a/Doc/ref3.tex
+++ /dev/null
@@ -1,885 +0,0 @@
-\chapter{Data model}
-
-\section{Objects, values and types}
-
-{\em Objects} are Python's abstraction for data.  All data in a Python
-program is represented by objects or by relations between objects.
-(In a sense, and in conformance to Von Neumann's model of a
-``stored program computer'', code is also represented by objects.)
-\index{object}
-\index{data}
-
-Every object has an identity, a type and a value.  An object's {\em
-identity} never changes once it has been created; you may think of it
-as the object's address in memory.  An object's {\em type} is also
-unchangeable.  It determines the operations that an object supports
-(e.g. ``does it have a length?'') and also defines the possible
-values for objects of that type.  The {\em value} of some objects can
-change.  Objects whose value can change are said to be {\em mutable};
-objects whose value is unchangeable once they are created are called
-{\em immutable}.  The type determines an object's (im)mutability.
-\index{identity of an object}
-\index{value of an object}
-\index{type of an object}
-\index{mutable object}
-\index{immutable object}
-
-Objects are never explicitly destroyed; however, when they become
-unreachable they may be garbage-collected.  An implementation is
-allowed to delay garbage collection or omit it altogether --- it is a
-matter of implementation quality how garbage collection is
-implemented, as long as no objects are collected that are still
-reachable.  (Implementation note: the current implementation uses a
-reference-counting scheme which collects most objects as soon as they
-become unreachable, but never collects garbage containing circular
-references.)
-\index{garbage collection}
-\index{reference counting}
-\index{unreachable object}
-
-Note that the use of the implementation's tracing or debugging
-facilities may keep objects alive that would normally be collectable.
-
-Some objects contain references to ``external'' resources such as open
-files or windows.  It is understood that these resources are freed
-when the object is garbage-collected, but since garbage collection is
-not guaranteed to happen, such objects also provide an explicit way to
-release the external resource, usually a \verb@close@ method.
-Programs are strongly recommended to always explicitly close such
-objects.
-
-Some objects contain references to other objects; these are called
-{\em containers}.  Examples of containers are tuples, lists and
-dictionaries.  The references are part of a container's value.  In
-most cases, when we talk about the value of a container, we imply the
-values, not the identities of the contained objects; however, when we
-talk about the (im)mutability of a container, only the identities of
-the immediately contained objects are implied.  (So, if an immutable
-container contains a reference to a mutable object, its value changes
-if that mutable object is changed.)
-\index{container}
-
-Types affect almost all aspects of objects' lives.  Even the meaning
-of object identity is affected in some sense: for immutable types,
-operations that compute new values may actually return a reference to
-any existing object with the same type and value, while for mutable
-objects this is not allowed.  E.g. after
-
-\begin{verbatim}
-a = 1; b = 1; c = []; d = []
-\end{verbatim}
-
-\verb@a@ and \verb@b@ may or may not refer to the same object with the
-value one, depending on the implementation, but \verb@c@ and \verb@d@
-are guaranteed to refer to two different, unique, newly created empty
-lists.
-
-\section{The standard type hierarchy} \label{types}
-
-Below is a list of the types that are built into Python.  Extension
-modules written in C can define additional types.  Future versions of
-Python may add types to the type hierarchy (e.g. rational or complex
-numbers, efficiently stored arrays of integers, etc.).
-\index{type}
-\indexii{data}{type}
-\indexii{type}{hierarchy}
-\indexii{extension}{module}
-\index{C}
-
-Some of the type descriptions below contain a paragraph listing
-`special attributes'.  These are attributes that provide access to the
-implementation and are not intended for general use.  Their definition
-may change in the future.  There are also some `generic' special
-attributes, not listed with the individual objects: \verb@__methods__@
-is a list of the method names of a built-in object, if it has any;
-\verb@__members__@ is a list of the data attribute names of a built-in
-object, if it has any.
-\index{attribute}
-\indexii{special}{attribute}
-\indexiii{generic}{special}{attribute}
-\ttindex{__methods__}
-\ttindex{__members__}
-
-\begin{description}
-
-\item[None]
-This type has a single value.  There is a single object with this value.
-This object is accessed through the built-in name \verb@None@.
-It is returned from functions that don't explicitly return an object.
-\ttindex{None}
-\obindex{None@{\tt None}}
-
-\item[Numbers]
-These are created by numeric literals and returned as results by
-arithmetic operators and arithmetic built-in functions.  Numeric
-objects are immutable; once created their value never changes.  Python
-numbers are of course strongly related to mathematical numbers, but
-subject to the limitations of numerical representation in computers.
-\obindex{number}
-\obindex{numeric}
-
-Python distinguishes between integers and floating point numbers:
-
-\begin{description}
-\item[Integers]
-These represent elements from the mathematical set of whole numbers.
-\obindex{integer}
-
-There are two types of integers:
-
-\begin{description}
-
-\item[Plain integers]
-These represent numbers in the range -2147483648 through 2147483647.
-(The range may be larger on machines with a larger natural word
-size, but not smaller.)
-When the result of an operation falls outside this range, the
-exception \verb@OverflowError@ is raised.
-For the purpose of shift and mask operations, integers are assumed to
-have a binary, 2's complement notation using 32 or more bits, and
-hiding no bits from the user (i.e., all 4294967296 different bit
-patterns correspond to different values).
-\obindex{plain integer}
-
-\item[Long integers]
-These represent numbers in an unlimited range, subject to available
-(virtual) memory only.  For the purpose of shift and mask operations,
-a binary representation is assumed, and negative numbers are
-represented in a variant of 2's complement which gives the illusion of
-an infinite string of sign bits extending to the left.
-\obindex{long integer}
-
-\end{description} % Integers
-
-The rules for integer representation are intended to give the most
-meaningful interpretation of shift and mask operations involving
-negative integers and the least surprises when switching between the
-plain and long integer domains.  For any operation except left shift,
-if it yields a result in the plain integer domain without causing
-overflow, it will yield the same result in the long integer domain or
-when using mixed operands.
-\indexii{integer}{representation}
-
-\item[Floating point numbers]
-These represent machine-level double precision floating point numbers.  
-You are at the mercy of the underlying machine architecture and
-C implementation for the accepted range and handling of overflow.
-\obindex{floating point}
-\indexii{floating point}{number}
-\index{C}
-
-\end{description} % Numbers
-
-\item[Sequences]
-These represent finite ordered sets indexed by natural numbers.
-The built-in function \verb@len()@ returns the number of elements
-of a sequence.  When this number is \var{n}, the index set contains
-the numbers 0, 1, \ldots, \var{n}-1.  Element \var{i} of sequence
-\var{a} is selected by \code{\var{a}[\var{i}]}.
-\obindex{seqence}
-\bifuncindex{len}
-\index{index operation}
-\index{item selection}
-\index{subscription}
-
-Sequences also support slicing: \verb@a[i:j]@ selects all elements
-with index \var{k} such that \var{i} \code{<=} \var{k} \code{<}
-\var{j}.  When used as an expression, a slice is a sequence of the
-same type --- this implies that the index set is renumbered so that it
-starts at 0 again.
-\index{slicing}
-
-Sequences are distinguished according to their mutability:
-
-\begin{description}
-%
-\item[Immutable sequences]
-An object of an immutable sequence type cannot change once it is
-created.  (If the object contains references to other objects,
-these other objects may be mutable and may be changed; however
-the collection of objects directly referenced by an immutable object
-cannot change.)
-\obindex{immutable sequence}
-\obindex{immutable}
-
-The following types are immutable sequences:
-
-\begin{description}
-
-\item[Strings]
-The elements of a string are characters.  There is no separate
-character type; a character is represented by a string of one element.
-Characters represent (at least) 8-bit bytes.  The built-in
-functions \verb@chr()@ and \verb@ord()@ convert between characters
-and nonnegative integers representing the byte values.
-Bytes with the values 0-127 represent the corresponding \ASCII{} values.
-The string data type is also used to represent arrays of bytes, e.g.
-to hold data read from a file.
-\obindex{string}
-\index{character}
-\index{byte}
-\index{ASCII}
-\bifuncindex{chr}
-\bifuncindex{ord}
-
-(On systems whose native character set is not \ASCII{}, strings may use
-EBCDIC in their internal representation, provided the functions
-\verb@chr()@ and \verb@ord()@ implement a mapping between \ASCII{} and
-EBCDIC, and string comparison preserves the \ASCII{} order.
-Or perhaps someone can propose a better rule?)
-\index{ASCII}
-\index{EBCDIC}
-\index{character set}
-\indexii{string}{comparison}
-\bifuncindex{chr}
-\bifuncindex{ord}
-
-\item[Tuples]
-The elements of a tuple are arbitrary Python objects.
-Tuples of two or more elements are formed by comma-separated lists
-of expressions.  A tuple of one element (a `singleton') can be formed
-by affixing a comma to an expression (an expression by itself does
-not create a tuple, since parentheses must be usable for grouping of
-expressions).  An empty tuple can be formed by enclosing `nothing' in
-parentheses.
-\obindex{tuple}
-\indexii{singleton}{tuple}
-\indexii{empty}{tuple}
-
-\end{description} % Immutable sequences
-
-\item[Mutable sequences]
-Mutable sequences can be changed after they are created.  The
-subscription and slicing notations can be used as the target of
-assignment and \verb@del@ (delete) statements.
-\obindex{mutable sequece}
-\obindex{mutable}
-\indexii{assignment}{statement}
-\index{delete}
-\stindex{del}
-\index{subscription}
-\index{slicing}
-
-There is currently a single mutable sequence type:
-
-\begin{description}
-
-\item[Lists]
-The elements of a list are arbitrary Python objects.  Lists are formed
-by placing a comma-separated list of expressions in square brackets.
-(Note that there are no special cases needed to form lists of length 0
-or 1.)
-\obindex{list}
-
-\end{description} % Mutable sequences
-
-\end{description} % Sequences
-
-\item[Mapping types]
-These represent finite sets of objects indexed by arbitrary index sets.
-The subscript notation \verb@a[k]@ selects the element indexed
-by \verb@k@ from the mapping \verb@a@; this can be used in
-expressions and as the target of assignments or \verb@del@ statements.
-The built-in function \verb@len()@ returns the number of elements
-in a mapping.
-\bifuncindex{len}
-\index{subscription}
-\obindex{mapping}
-
-There is currently a single mapping type:
-
-\begin{description}
-
-\item[Dictionaries]
-These represent finite sets of objects indexed by almost arbitrary
-values.  The only types of values not acceptable as keys are values
-containing lists or dictionaries or other mutable types that are
-compared by value rather than by object identity --- the reason being
-that the implementation requires that a key's hash value be constant.
-Numeric types used for keys obey the normal rules for numeric
-comparison: if two numbers compare equal (e.g. 1 and 1.0) then they
-can be used interchangeably to index the same dictionary entry.
-
-Dictionaries are mutable; they are created by the \verb@{...}@
-notation (see section \ref{dict}).
-\obindex{dictionary}
-\obindex{mutable}
-
-\end{description} % Mapping types
-
-\item[Callable types]
-These are the types to which the function call (invocation) operation,
-written as \verb@function(argument, argument, ...)@, can be applied:
-\indexii{function}{call}
-\index{invocation}
-\indexii{function}{argument}
-\obindex{callable}
-
-\begin{description}
-
-\item[User-defined functions]
-A user-defined function object is created by a function definition
-(see section \ref{function}).  It should be called with an argument
-list containing the same number of items as the function's formal
-parameter list.
-\indexii{user-defined}{function}
-\obindex{function}
-\obindex{user-defined function}
-
-Special read-only attributes: \verb@func_code@ is the code object
-representing the compiled function body, and \verb@func_globals@ is (a
-reference to) the dictionary that holds the function's global
-variables --- it implements the global name space of the module in
-which the function was defined.
-\ttindex{func_code}
-\ttindex{func_globals}
-\indexii{global}{name space}
-
-\item[User-defined methods]
-A user-defined method (a.k.a. {\em object closure}) is a pair of a
-class instance object and a user-defined function.  It should be
-called with an argument list containing one item less than the number
-of items in the function's formal parameter list.  When called, the
-class instance becomes the first argument, and the call arguments are
-shifted one to the right.
-\obindex{method}
-\obindex{user-defined method}
-\indexii{user-defined}{method}
-\index{object closure}
-
-Special read-only attributes: \verb@im_self@ is the class instance
-object, \verb@im_func@ is the function object.
-\ttindex{im_func}
-\ttindex{im_self}
-
-\item[Built-in functions]
-A built-in function object is a wrapper around a C function.  Examples
-of built-in functions are \verb@len@ and \verb@math.sin@.  There
-are no special attributes.  The number and type of the arguments are
-determined by the C function.
-\obindex{built-in function}
-\obindex{function}
-\index{C}
-
-\item[Built-in methods]
-This is really a different disguise of a built-in function, this time
-containing an object passed to the C function as an implicit extra
-argument.  An example of a built-in method is \verb@list.append@ if
-\verb@list@ is a list object.
-\obindex{built-in method}
-\obindex{method}
-\indexii{built-in}{method}
-
-\item[Classes]
-Class objects are described below.  When a class object is called as a
-function, a new class instance (also described below) is created and
-returned.  This implies a call to the class's \verb@__init__@ method
-if it has one.  Any arguments are passed on to the \verb@__init__@
-method --- if there is no \verb@__init__@ method, the class must be called
-without arguments.
-\ttindex{__init__}
-\obindex{class}
-\obindex{class instance}
-\obindex{instance}
-\indexii{class object}{call}
-
-\end{description}
-
-\item[Modules]
-Modules are imported by the \verb@import@ statement (see section
-\ref{import}).  A module object is a container for a module's name
-space, which is a dictionary (the same dictionary as referenced by the
-\verb@func_globals@ attribute of functions defined in the module).
-Module attribute references are translated to lookups in this
-dictionary.  A module object does not contain the code object used to
-initialize the module (since it isn't needed once the initialization
-is done).
-\stindex{import}
-\obindex{module}
-
-Attribute assignment update the module's name space dictionary.
-
-Special read-only attribute: \verb@__dict__@ yields the module's name
-space as a dictionary object.  Predefined attributes: \verb@__name__@
-yields the module's name as a string object; \verb@__doc__@ yields the
-module's documentation string as a string object, or
-\verb@None@ if no documentation string was found.
-\ttindex{__dict__}
-\ttindex{__name__}
-\ttindex{__doc__}
-\indexii{module}{name space}
-
-\item[Classes]
-Class objects are created by class definitions (see section
-\ref{class}).  A class is a container for a dictionary containing the
-class's name space.  Class attribute references are translated to
-lookups in this dictionary.  When an attribute name is not found
-there, the attribute search continues in the base classes.  The search
-is depth-first, left-to-right in the order of their occurrence in the
-base class list.
-\obindex{class}
-\obindex{class instance}
-\obindex{instance}
-\indexii{class object}{call}
-\index{container}
-\obindex{dictionary}
-\indexii{class}{attribute}
-
-Class attribute assignments update the class's dictionary, never the
-dictionary of a base class.
-\indexiii{class}{attribute}{assignment}
-
-A class can be called as a function to yield a class instance (see
-above).
-\indexii{class object}{call}
-
-Special read-only attributes: \verb@__dict__@ yields the dictionary
-containing the class's name space; \verb@__bases__@ yields a tuple
-(possibly empty or a singleton) containing the base classes, in the
-order of their occurrence in the base class list.
-\ttindex{__dict__}
-\ttindex{__bases__}
-
-\item[Class instances]
-A class instance is created by calling a class object as a
-function.  A class instance has a dictionary in which
-attribute references are searched.  When an attribute is not found
-there, and the instance's class has an attribute by that name, and
-that class attribute is a user-defined function (and in no other
-cases), the instance attribute reference yields a user-defined method
-object (see above) constructed from the instance and the function.
-\obindex{class instance}
-\obindex{instance}
-\indexii{class}{instance}
-\indexii{class instance}{attribute}
-
-Attribute assignments update the instance's dictionary.
-\indexiii{class instance}{attribute}{assignment}
-
-Class instances can pretend to be numbers, sequences, or mappings if
-they have methods with certain special names.  These are described in
-section \ref{specialnames}.
-\obindex{number}
-\obindex{sequence}
-\obindex{mapping}
-
-Special read-only attributes: \verb@__dict__@ yields the attribute
-dictionary; \verb@__class__@ yields the instance's class.
-\ttindex{__dict__}
-\ttindex{__class__}
-
-\item[Files]
-A file object represents an open file.  (It is a wrapper around a C
-{\tt stdio} file pointer.)  File objects are created by the
-\verb@open()@ built-in function, and also by \verb@posix.popen()@ and
-the \verb@makefile@ method of socket objects.  \verb@sys.stdin@,
-\verb@sys.stdout@ and \verb@sys.stderr@ are file objects corresponding
-to the interpreter's standard input, output and error streams.
-See the Python Library Reference for methods of file objects and other
-details.
-\obindex{file}
-\index{C}
-\index{stdio}
-\bifuncindex{open}
-\bifuncindex{popen}
-\bifuncindex{makefile}
-\ttindex{stdin}
-\ttindex{stdout}
-\ttindex{stderr}
-\ttindex{sys.stdin}
-\ttindex{sys.stdout}
-\ttindex{sys.stderr}
-
-\item[Internal types]
-A few types used internally by the interpreter are exposed to the user.
-Their definition may change with future versions of the interpreter,
-but they are mentioned here for completeness.
-\index{internal type}
-
-\begin{description}
-
-\item[Code objects]
-Code objects represent ``pseudo-compiled'' executable Python code.
-The difference between a code
-object and a function object is that the function object contains an
-explicit reference to the function's context (the module in which it
-was defined) while a code object contains no context.
-\obindex{code}
-
-Special read-only attributes: \verb@co_code@ is a string representing
-the sequence of instructions; \verb@co_consts@ is a list of literals
-used by the code; \verb@co_names@ is a list of names (strings) used by
-the code; \verb@co_filename@ is the filename from which the code was
-compiled.  (To find out the line numbers, you would have to decode the
-instructions; the standard library module \verb@dis@ contains an
-example of how to do this.)
-\ttindex{co_code}
-\ttindex{co_consts}
-\ttindex{co_names}
-\ttindex{co_filename}
-
-\item[Frame objects]
-Frame objects represent execution frames.  They may occur in traceback
-objects (see below).
-\obindex{frame}
-
-Special read-only attributes: \verb@f_back@ is to the previous
-stack frame (towards the caller), or \verb@None@ if this is the bottom
-stack frame; \verb@f_code@ is the code object being executed in this
-frame; \verb@f_globals@ is the dictionary used to look up global
-variables; \verb@f_locals@ is used for local variables;
-\verb@f_lineno@ gives the line number and \verb@f_lasti@ gives the
-precise instruction (this is an index into the instruction string of
-the code object).
-\ttindex{f_back}
-\ttindex{f_code}
-\ttindex{f_globals}
-\ttindex{f_locals}
-\ttindex{f_lineno}
-\ttindex{f_lasti}
-
-\item[Traceback objects] \label{traceback}
-Traceback objects represent a stack trace of an exception.  A
-traceback object is created when an exception occurs.  When the search
-for an exception handler unwinds the execution stack, at each unwound
-level a traceback object is inserted in front of the current
-traceback.  When an exception handler is entered
-(see also section \ref{try}), the stack trace is
-made available to the program as \verb@sys.exc_traceback@.  When the
-program contains no suitable handler, the stack trace is written
-(nicely formatted) to the standard error stream; if the interpreter is
-interactive, it is also made available to the user as
-\verb@sys.last_traceback@.
-\obindex{traceback}
-\indexii{stack}{trace}
-\indexii{exception}{handler}
-\indexii{execution}{stack}
-\ttindex{exc_traceback}
-\ttindex{last_traceback}
-\ttindex{sys.exc_traceback}
-\ttindex{sys.last_traceback}
-
-Special read-only attributes: \verb@tb_next@ is the next level in the
-stack trace (towards the frame where the exception occurred), or
-\verb@None@ if there is no next level; \verb@tb_frame@ points to the
-execution frame of the current level; \verb@tb_lineno@ gives the line
-number where the exception occurred; \verb@tb_lasti@ indicates the
-precise instruction.  The line number and last instruction in the
-traceback may differ from the line number of its frame object if the
-exception occurred in a \verb@try@ statement with no matching
-\verb@except@ clause or with a \verb@finally@ clause.
-\ttindex{tb_next}
-\ttindex{tb_frame}
-\ttindex{tb_lineno}
-\ttindex{tb_lasti}
-\stindex{try}
-
-\end{description} % Internal types
-
-\end{description} % Types
-
-
-\section{Special method names} \label{specialnames}
-
-A class can implement certain operations that are invoked by special
-syntax (such as subscription or arithmetic operations) by defining
-methods with special names.  For instance, if a class defines a
-method named \verb@__getitem__@, and \verb@x@ is an instance of this
-class, then \verb@x[i]@ is equivalent to \verb@x.__getitem__(i)@.
-(The reverse is not true --- if \verb@x@ is a list object,
-\verb@x.__getitem__(i)@ is not equivalent to \verb@x[i]@.)
-\ttindex{__getitem__}
-
-Except for \verb@__repr__@, \verb@__str__@ and \verb@__cmp__@,
-attempts to execute an
-operation raise an exception when no appropriate method is defined.
-For \verb@__repr__@, the default is to return a string describing the
-object's class and address.
-For \verb@__cmp__@, the default is to compare instances based on their
-address.
-For \verb@__str__@, the default is to use \verb@__repr__@.
-\ttindex{__repr__}
-\ttindex{__str__}
-\ttindex{__cmp__}
-
-
-\subsection{Special methods for any type}
-
-\begin{description}
-
-\item[{\tt __init__(self, args...)}]
-Called when the instance is created.  The arguments are those passed
-to the class constructor expression.  If a base class has an
-\code{__init__} method the derived class's \code{__init__} method must
-explicitly call it to ensure proper initialization of the base class
-part of the instance.
-\ttindex{__init__}
-\indexii{class}{constructor}
-
-
-\item[{\tt __del__(self)}]
-Called when the instance is about to be destroyed.  If a base class
-has an \code{__del__} method the derived class's \code{__del__} method
-must explicitly call it to ensure proper deletion of the base class
-part of the instance.  Note that it is possible for the \code{__del__}
-method to postpone destruction of the instance by creating a new
-reference to it.  It may then be called at a later time when this new
-reference is deleted.  It is not guaranteed that
-\code{__del__} methods are called for objects that still exist when
-the interpreter exits.
-If an exception occurs in a \code{__del__} method, it is ignored, and
-a warning is printed on stderr.
-\ttindex{__del__}
-\stindex{del}
-
-Note that \code{del x} doesn't directly call \code{x.__del__} --- the
-former decrements the reference count for \code{x} by one, but
-\code{x.__del__} is only called when its reference count reaches zero.
-
-\strong{Warning:} due to the precarious circumstances under which
-\code{__del__} methods are executed, exceptions that occur during
-their execution are \emph{ignored}.
-
-\item[{\tt __repr__(self)}]
-Called by the \verb@repr()@ built-in function and by string conversions
-(reverse or backward quotes) to compute the string representation of an object.
-\ttindex{__repr__}
-\bifuncindex{repr}
-\indexii{string}{conversion}
-\indexii{reverse}{quotes}
-\indexii{backward}{quotes}
-\index{back-quotes}
-
-\item[{\tt __str__(self)}]
-Called by the \verb@str()@ built-in function and by the \verb@print@
-statement compute the string representation of an object.
-\ttindex{__str__}
-\bifuncindex{str}
-\stindex{print}
-
-\item[{\tt __cmp__(self, other)}]
-Called by all comparison operations.  Should return -1 if
-\verb@self < other@,  0 if \verb@self == other@, +1 if
-\verb@self > other@.  If no \code{__cmp__} operation is defined, class
-instances are compared by object identity (``address'').
-(Implementation note: due to limitations in the interpreter,
-exceptions raised by comparisons are ignored, and the objects will be
-considered equal in this case.)
-\ttindex{__cmp__}
-\bifuncindex{cmp}
-\index{comparisons}
-
-\item[{\tt __hash__(self)}]
-Called for the key object for dictionary operations,
-and by the built-in function
-\code{hash()}.  Should return a 32-bit integer usable as a hash value
-for dictionary operations.  The only required property is that objects
-which compare equal have the same hash value; it is advised to somehow
-mix together (e.g. using exclusive or) the hash values for the
-components of the object that also play a part in comparison of
-objects.  If a class does not define a \code{__cmp__} method it should
-not define a \code{__hash__} operation either; if it defines
-\code{__cmp__} but not \code{__hash__} its instances will not be
-usable as dictionary keys.  If a class defines mutable objects and
-implements a \code{__cmp__} method it should not implement
-\code{__hash__}, since the dictionary implementation assumes that a
-key's hash value is a constant.
-\obindex{dictionary}
-\ttindex{__cmp__}
-\ttindex{__hash__}
-\bifuncindex{hash}
-
-\item[{\tt __call__(self, *args)}]
-Called when the instance is ``called'' as a function.
-\ttindex{__call__}
-\indexii{call}{instance}
-
-\end{description}
-
-
-\subsection{Special methods for attribute access}
-
-The following methods can be used to change the meaning of attribute
-access for class instances.
-
-\begin{description}
-
-\item[{\tt __getattr__(self, name)}]
-Called when an attribute lookup has not found the attribute in the
-usual places (i.e. it is not an instance attribute nor is it found in
-the class tree for \code{self}).  \code{name} is the attribute name.
-\ttindex{__getattr__}
-
-Note that if the attribute is found through the normal mechanism,
-\code{__getattr__} is not called.  (This is an asymmetry between
-\code{__getattr__} and \code{__setattr__}.)
-This is done both for efficiency reasons and because otherwise
-\code{__getattr__} would have no way to access other attributes of the
-instance.
-Note that at least for instance variables, \code{__getattr__} can fake
-total control by simply not inserting any values in the instance
-attribute dictionary.
-\ttindex{__setattr__}
-
-\item[{\tt __setattr__(self, name, value)}]
-Called when an attribute assignment is attempted.  This is called
-instead of the normal mechanism (i.e. store the value as an instance
-attribute).  \code{name} is the attribute name, \code{value} is the
-value to be assigned to it.
-\ttindex{__setattr__}
-
-If \code{__setattr__} wants to assign to an instance attribute, it
-should not simply execute \code{self.\var{name} = value} --- this would
-cause a recursive call.  Instead, it should insert the value in the
-dictionary of instance attributes, e.g. \code{self.__dict__[name] =
-value}.
-\ttindex{__dict__}
-
-\item[{\tt __delattr__(self, name)}]
-Like \code{__setattr__} but for attribute deletion instead of
-assignment.
-\ttindex{__delattr__}
-
-\end{description}
-
-
-\subsection{Special methods for sequence and mapping types}
-
-\begin{description}
-
-\item[{\tt __len__(self)}]
-Called to implement the built-in function \verb@len()@.  Should return
-the length of the object, an integer \verb@>=@ 0.  Also, an object
-whose \verb@__len__()@ method returns 0 is considered to be false in a
-Boolean context.
-\ttindex{__len__}
-
-\item[{\tt __getitem__(self, key)}]
-Called to implement evaluation of \verb@self[key]@.  Note that the
-special interpretation of negative keys (if the class wishes to
-emulate a sequence type) is up to the \verb@__getitem__@ method.
-\ttindex{__getitem__}
-
-\item[{\tt __setitem__(self, key, value)}]
-Called to implement assignment to \verb@self[key]@.  Same note as for
-\verb@__getitem__@.
-\ttindex{__setitem__}
-
-\item[{\tt __delitem__(self, key)}]
-Called to implement deletion of \verb@self[key]@.  Same note as for
-\verb@__getitem__@.
-\ttindex{__delitem__}
-
-\end{description}
-
-
-\subsection{Special methods for sequence types}
-
-\begin{description}
-
-\item[{\tt __getslice__(self, i, j)}]
-Called to implement evaluation of \verb@self[i:j]@.  Note that missing
-\verb@i@ or \verb@j@ are replaced by 0 or \verb@len(self)@,
-respectively, and \verb@len(self)@ has been added (once) to originally
-negative \verb@i@ or \verb@j@ by the time this function is called
-(unlike for \verb@__getitem__@).
-\ttindex{__getslice__}
-
-\item[{\tt __setslice__(self, i, j, sequence)}]
-Called to implement assignment to \verb@self[i:j]@.  Same notes as for
-\verb@__getslice__@.
-\ttindex{__setslice__}
-
-\item[{\tt __delslice__(self, i, j)}]
-Called to implement deletion of \verb@self[i:j]@.  Same notes as for
-\verb@__getslice__@.
-\ttindex{__delslice__}
-
-\end{description}
-
-
-\subsection{Special methods for numeric types}
-
-\begin{description}
-
-\item[{\tt __add__(self, other)}]\itemjoin
-\item[{\tt __sub__(self, other)}]\itemjoin
-\item[{\tt __mul__(self, other)}]\itemjoin
-\item[{\tt __div__(self, other)}]\itemjoin
-\item[{\tt __mod__(self, other)}]\itemjoin
-\item[{\tt __divmod__(self, other)}]\itemjoin
-\item[{\tt __pow__(self, other)}]\itemjoin
-\item[{\tt __lshift__(self, other)}]\itemjoin
-\item[{\tt __rshift__(self, other)}]\itemjoin
-\item[{\tt __and__(self, other)}]\itemjoin
-\item[{\tt __xor__(self, other)}]\itemjoin
-\item[{\tt __or__(self, other)}]\itembreak
-Called to implement the binary arithmetic operations (\verb@+@,
-\verb@-@, \verb@*@, \verb@/@, \verb@%@, \verb@divmod()@, \verb@pow()@,
-\verb@<<@, \verb@>>@, \verb@&@, \verb@^@, \verb@|@).
-\ttindex{__or__}
-\ttindex{__xor__}
-\ttindex{__and__}
-\ttindex{__rshift__}
-\ttindex{__lshift__}
-\ttindex{__pow__}
-\ttindex{__divmod__}
-\ttindex{__mod__}
-\ttindex{__div__}
-\ttindex{__mul__}
-\ttindex{__sub__}
-\ttindex{__add__}
-
-\item[{\tt __neg__(self)}]\itemjoin
-\item[{\tt __pos__(self)}]\itemjoin
-\item[{\tt __abs__(self)}]\itemjoin
-\item[{\tt __invert__(self)}]\itembreak
-Called to implement the unary arithmetic operations (\verb@-@, \verb@+@,
-\verb@abs()@ and \verb@~@).
-\ttindex{__invert__}
-\ttindex{__abs__}
-\ttindex{__pos__}
-\ttindex{__neg__}
-
-\item[{\tt __nonzero__(self)}]
-Called to implement boolean testing; should return 0 or 1.  An
-alternative name for this method is \verb@__len__@.
-\ttindex{__nonzero__}
-
-\item[{\tt __coerce__(self, other)}]
-Called to implement ``mixed-mode'' numeric arithmetic.  Should either
-return a tuple containing self and other converted to a common numeric
-type, or None if no way of conversion is known.  When the common type
-would be the type of other, it is sufficient to return None, since the
-interpreter will also ask the other object to attempt a coercion (but
-sometimes, if the implementation of the other type cannot be changed,
-it is useful to do the conversion to the other type here).
-\ttindex{__coerce__}
-
-Note that this method is not called to coerce the arguments to \verb@+@
-and \verb@*@, because these are also used to implement sequence
-concatenation and repetition, respectively.  Also note that, for the
-same reason, in \verb@n*x@, where \verb@n@ is a built-in number and
-\verb@x@ is an instance, a call to \verb@x.__mul__(n)@ is made.%
-\footnote{The interpreter should really distinguish between
-user-defined classes implementing sequences, mappings or numbers, but
-currently it doesn't --- hence this strange exception.}
-\ttindex{__mul__}
-
-\item[{\tt __int__(self)}]\itemjoin
-\item[{\tt __long__(self)}]\itemjoin
-\item[{\tt __float__(self)}]\itembreak
-Called to implement the built-in functions \verb@int()@, \verb@long()@
-and \verb@float()@.  Should return a value of the appropriate type.
-\ttindex{__float__}
-\ttindex{__long__}
-\ttindex{__int__}
-
-\item[{\tt __oct__(self)}]\itemjoin
-\item[{\tt __hex__(self)}]\itembreak
-Called to implement the built-in functions \verb@oct()@ and
-\verb@hex()@.  Should return a string value.
-\ttindex{__hex__}
-\ttindex{__oct__}
-
-\end{description}
diff --git a/Doc/ref4.tex b/Doc/ref4.tex
deleted file mode 100644
index 4b4d522..0000000
--- a/Doc/ref4.tex
+++ /dev/null
@@ -1,201 +0,0 @@
-\chapter{Execution model}
-\index{execution model}
-
-\section{Code blocks, execution frames, and name spaces} \label{execframes}
-\index{code block}
-\indexii{execution}{frame}
-\index{name space}
-
-A {\em code block} is a piece of Python program text that can be
-executed as a unit, such as a module, a class definition or a function
-body.  Some code blocks (like modules) are executed only once, others
-(like function bodies) may be executed many times.  Code blocks may
-textually contain other code blocks.  Code blocks may invoke other
-code blocks (that may or may not be textually contained in them) as
-part of their execution, e.g. by invoking (calling) a function.
-\index{code block}
-\indexii{code}{block}
-
-The following are code blocks:  A module is a code block.  A function
-body is a code block.  A class definition is a code block.  Each
-command typed interactively is a separate code block; a script file is
-a code block.  The string argument passed to the built-in function
-\verb@eval@ and to the \verb@exec@ statement are code blocks.
-And finally, the
-expression read and evaluated by the built-in function \verb@input@ is
-a code block.
-
-A code block is executed in an execution frame.  An {\em execution
-frame} contains some administrative information (used for debugging),
-determines where and how execution continues after the code block's
-execution has completed, and (perhaps most importantly) defines two
-name spaces, the local and the global name space, that affect
-execution of the code block.
-\indexii{execution}{frame}
-
-A {\em name space} is a mapping from names (identifiers) to objects.
-A particular name space may be referenced by more than one execution
-frame, and from other places as well.  Adding a name to a name space
-is called {\em binding} a name (to an object); changing the mapping of
-a name is called {\em rebinding}; removing a name is {\em unbinding}.
-Name spaces are functionally equivalent to dictionaries.
-\index{name space}
-\indexii{binding}{name}
-\indexii{rebinding}{name}
-\indexii{unbinding}{name}
-
-The {\em local name space} of an execution frame determines the default
-place where names are defined and searched.  The {\em global name
-space} determines the place where names listed in \verb@global@
-statements are defined and searched, and where names that are not
-explicitly bound in the current code block are searched.
-\indexii{local}{name space}
-\indexii{global}{name space}
-\stindex{global}
-
-Whether a name is local or global in a code block is determined by
-static inspection of the source text for the code block: in the
-absence of \verb@global@ statements, a name that is bound anywhere in
-the code block is local in the entire code block; all other names are
-considered global.  The \verb@global@ statement forces global
-interpretation of selected names throughout the code block.  The
-following constructs bind names: formal parameters, \verb@import@
-statements, class and function definitions (these bind the class or
-function name), and targets that are identifiers if occurring in an
-assignment, \verb@for@ loop header, or \verb@except@ clause header.
-
-A target occurring in a \verb@del@ statement is also considered bound
-for this purpose (though the actual semantics are to ``unbind'' the
-name).
-
-When a global name is not found in the global name space, it is
-searched in the list of ``built-in'' names (which is actually the
-global name space of the module \verb@__builtin__@).  When a name is not
-found at all, the \verb@NameError@ exception is raised.%
-\footnote{If the code block contains {\tt exec} statements or the
-construct {\tt from \ldots import *}, the semantics of names not
-explicitly mentioned in a {\tt global} statement change subtly: name
-lookup first searches the local name space, then the global one, then
-the built-in one.}
-\bimodindex{__builtin__}
-\stindex{from}
-\stindex{exec}
-\stindex{global}
-\ttindex{NameError}
-
-The following table lists the meaning of the local and global name
-space for various types of code blocks.  The name space for a
-particular module is automatically created when the module is first
-referenced.  Note that in almost all cases, the global name space is
-the name space of the containing module --- scopes in Python do not
-nest!
-
-\begin{center}
-\begin{tabular}{|l|l|l|l|}
-\hline
-Code block type & Global name space & Local name space & Notes \\
-\hline
-Module & n.s. for this module & same as global & \\
-Script & n.s. for \verb@__main__@ & same as global & \\
-Interactive command & n.s. for \verb@__main__@ & same as global & \\
-Class definition & global n.s. of containing block & new n.s. & \\
-Function body & global n.s. of containing block & new n.s. & (2) \\
-String passed to \verb@exec@ statement
-	& global n.s. of containing block
-		& local n.s. of containing block & (1) \\
-String passed to \verb@eval()@
-	& global n.s. of caller & local n.s. of caller & (1) \\
-File read by \verb@execfile()@
-	& global n.s. of caller & local n.s. of caller & (1) \\
-Expression read by \verb@input@
-	& global n.s. of caller & local n.s. of caller & \\
-\hline
-\end{tabular}
-\end{center}
-\bimodindex{__main__}
-
-Notes:
-
-\begin{description}
-
-\item[n.s.] means {\em name space}
-
-\item[(1)] The global and local name space for these can be
-overridden with optional extra arguments.
-
-\item[(2)] The body of lambda forms (see section \ref{lambda}) is
-treated exactly the same as a (nested) function definition.  Lambda
-forms have their own name space consisting of their formal arguments.
-\indexii{lambda}{form}
-
-\end{description}
-
-The built-in functions \verb@globals()@ and \verb@locals()@ returns a
-dictionary representing the current global and local name space,
-respectively.  The effect of modifications to this dictionary on the
-name space are undefined.%
-\footnote{The current implementations return the dictionary actually 
-used to implement the name space, {\em except} for functions, where
-the optimizer may cause the local name space to be implemented
-differently, and \verb@locals()@ returns a read-only dictionary.}
-
-\section{Exceptions}
-
-Exceptions are a means of breaking out of the normal flow of control
-of a code block in order to handle errors or other exceptional
-conditions.  An exception is {\em raised} at the point where the error
-is detected; it may be {\em handled} by the surrounding code block or
-by any code block that directly or indirectly invoked the code block
-where the error occurred.
-\index{exception}
-\index{raise an exception}
-\index{handle an exception}
-\index{exception handler}
-\index{errors}
-\index{error handling}
-
-The Python interpreter raises an exception when it detects an run-time
-error (such as division by zero).  A Python program can also
-explicitly raise an exception with the \verb@raise@ statement.
-Exception handlers are specified with the \verb@try...except@
-statement.
-
-Python uses the ``termination'' model of error handling: an exception
-handler can find out what happened and continue execution at an outer
-level, but it cannot repair the cause of the error and retry the
-failing operation (except by re-entering the the offending piece of
-code from the top).
-
-When an exception is not handled at all, the interpreter terminates
-execution of the program, or returns to its interactive main loop.
-
-Exceptions are identified by string objects or class instances.  Two
-different string objects with the same value identify different
-exceptions.  An exception can be raised with a class instance.  Such
-exceptions are caught by specifying an except clause that has the
-class name (or a base class) as the condition.
-
-When an exception is raised, an object (maybe \verb@None@) is passed
-as the exception's ``parameter''; this object does not affect the
-selection of an exception handler, but is passed to the selected
-exception handler as additional information.  For exceptions raised
-with a class instance, the instance is passed as the ``parameter''.
-
-For example:
-
-\begin{verbatim}
->>> class Error:
-...     def __init__(self, msg): self.msg = msg
-... 
->>> class SpecificError(Error): pass
-... 
->>> try:
-...     raise SpecificError('broken')
-... except Error, obj:
-...     print obj.msg
-... 
-broken
-\end{verbatim}
-
-See also the description of the \verb@try@ and \verb@raise@
-statements.
diff --git a/Doc/ref5.tex b/Doc/ref5.tex
deleted file mode 100644
index b2fea3c..0000000
--- a/Doc/ref5.tex
+++ /dev/null
@@ -1,759 +0,0 @@
-\chapter{Expressions and conditions}
-\index{expression}
-\index{condition}
-
-{\bf Note:} In this and the following chapters, extended BNF notation
-will be used to describe syntax, not lexical analysis.
-\index{BNF}
-
-This chapter explains the meaning of the elements of expressions and
-conditions.  Conditions are a superset of expressions, and a condition
-may be used wherever an expression is required by enclosing it in
-parentheses.  The only places where expressions are used in the syntax
-instead of conditions is in expression statements and on the
-right-hand side of assignment statements; this catches some nasty bugs
-like accidentally writing \verb@x == 1@ instead of \verb@x = 1@.
-\indexii{assignment}{statement}
-
-The comma plays several roles in Python's syntax.  It is usually an
-operator with a lower precedence than all others, but occasionally
-serves other purposes as well; e.g. it separates function arguments,
-is used in list and dictionary constructors, and has special semantics
-in \verb@print@ statements.
-\index{comma}
-
-When (one alternative of) a syntax rule has the form
-
-\begin{verbatim}
-name:           othername
-\end{verbatim}
-
-and no semantics are given, the semantics of this form of \verb@name@
-are the same as for \verb@othername@.
-\index{syntax}
-
-\section{Arithmetic conversions}
-\indexii{arithmetic}{conversion}
-
-When a description of an arithmetic operator below uses the phrase
-``the numeric arguments are converted to a common type'',
-this both means that if either argument is not a number, a
-\verb@TypeError@ exception is raised, and that otherwise
-the following conversions are applied:
-\exindex{TypeError}
-\indexii{floating point}{number}
-\indexii{long}{integer}
-\indexii{plain}{integer}
-
-\begin{itemize}
-\item	first, if either argument is a floating point number,
-	the other is converted to floating point;
-\item	else, if either argument is a long integer,
-	the other is converted to long integer;
-\item	otherwise, both must be plain integers and no conversion
-	is necessary.
-\end{itemize}
-
-\section{Atoms}
-\index{atom}
-
-Atoms are the most basic elements of expressions.  Forms enclosed in
-reverse quotes or in parentheses, brackets or braces are also
-categorized syntactically as atoms.  The syntax for atoms is:
-
-\begin{verbatim}
-atom:      identifier | literal | enclosure
-enclosure: parenth_form|list_display|dict_display|string_conversion
-\end{verbatim}
-
-\subsection{Identifiers (Names)}
-\index{name}
-\index{identifier}
-
-An identifier occurring as an atom is a reference to a local, global
-or built-in name binding.  If a name is assigned to anywhere in a code
-block (even in unreachable code), and is not mentioned in a
-\verb@global@ statement in that code block, then it refers to a local
-name throughout that code block.  When it is not assigned to anywhere
-in the block, or when it is assigned to but also explicitly listed in
-a \verb@global@ statement, it refers to a global name if one exists,
-else to a built-in name (and this binding may dynamically change).
-\indexii{name}{binding}
-\index{code block}
-\stindex{global}
-\indexii{built-in}{name}
-\indexii{global}{name}
-
-When the name is bound to an object, evaluation of the atom yields
-that object.  When a name is not bound, an attempt to evaluate it
-raises a \verb@NameError@ exception.
-\exindex{NameError}
-
-\subsection{Literals}
-\index{literal}
-
-Python knows string and numeric literals:
-
-\begin{verbatim}
-literal:        stringliteral | integer | longinteger | floatnumber
-\end{verbatim}
-
-Evaluation of a literal yields an object of the given type (string,
-integer, long integer, floating point number) with the given value.
-The value may be approximated in the case of floating point literals.
-See section \ref{literals} for details.
-
-All literals correspond to immutable data types, and hence the
-object's identity is less important than its value.  Multiple
-evaluations of literals with the same value (either the same
-occurrence in the program text or a different occurrence) may obtain
-the same object or a different object with the same value.
-\indexiii{immutable}{data}{type}
-
-(In the original implementation, all literals in the same code block
-with the same type and value yield the same object.)
-
-\subsection{Parenthesized forms}
-\index{parenthesized form}
-
-A parenthesized form is an optional condition list enclosed in
-parentheses:
-
-\begin{verbatim}
-parenth_form:      "(" [condition_list] ")"
-\end{verbatim}
-
-A parenthesized condition list yields whatever that condition list
-yields.
-
-An empty pair of parentheses yields an empty tuple object.  Since
-tuples are immutable, the rules for literals apply here.
-\indexii{empty}{tuple}
-
-(Note that tuples are not formed by the parentheses, but rather by use
-of the comma operator.  The exception is the empty tuple, for which
-parentheses {\em are} required --- allowing unparenthesized ``nothing''
-in expressions would cause ambiguities and allow common typos to
-pass uncaught.)
-\index{comma}
-\indexii{tuple}{display}
-
-\subsection{List displays}
-\indexii{list}{display}
-
-A list display is a possibly empty series of conditions enclosed in
-square brackets:
-
-\begin{verbatim}
-list_display:   "[" [condition_list] "]"
-\end{verbatim}
-
-A list display yields a new list object.
-\obindex{list}
-
-If it has no condition list, the list object has no items.  Otherwise,
-the elements of the condition list are evaluated from left to right
-and inserted in the list object in that order.
-\indexii{empty}{list}
-
-\subsection{Dictionary displays} \label{dict}
-\indexii{dictionary}{display}
-
-A dictionary display is a possibly empty series of key/datum pairs
-enclosed in curly braces:
-\index{key}
-\index{datum}
-\index{key/datum pair}
-
-\begin{verbatim}
-dict_display:   "{" [key_datum_list] "}"
-key_datum_list: key_datum ("," key_datum)* [","]
-key_datum:      condition ":" condition
-\end{verbatim}
-
-A dictionary display yields a new dictionary object.
-\obindex{dictionary}
-
-The key/datum pairs are evaluated from left to right to define the
-entries of the dictionary: each key object is used as a key into the
-dictionary to store the corresponding datum.
-
-Restrictions on the types of the key values are listed earlier in
-section \ref{types}.
-Clashes between duplicate keys are not detected; the last
-datum (textually rightmost in the display) stored for a given key
-value prevails.
-\exindex{TypeError}
-
-\subsection{String conversions}
-\indexii{string}{conversion}
-\indexii{reverse}{quotes}
-\indexii{backward}{quotes}
-\index{back-quotes}
-
-A string conversion is a condition list enclosed in reverse (or
-backward) quotes:
-
-\begin{verbatim}
-string_conversion: "`" condition_list "`"
-\end{verbatim}
-
-A string conversion evaluates the contained condition list and
-converts the resulting object into a string according to rules
-specific to its type.
-
-If the object is a string, a number, \verb@None@, or a tuple, list or
-dictionary containing only objects whose type is one of these, the
-resulting string is a valid Python expression which can be passed to
-the built-in function \verb@eval()@ to yield an expression with the
-same value (or an approximation, if floating point numbers are
-involved).
-
-(In particular, converting a string adds quotes around it and converts
-``funny'' characters to escape sequences that are safe to print.)
-
-It is illegal to attempt to convert recursive objects (e.g. lists or
-dictionaries that contain a reference to themselves, directly or
-indirectly.)
-\obindex{recursive}
-
-The built-in function \verb@repr()@ performs exactly the same
-conversion in its argument as enclosing it it reverse quotes does.
-The built-in function \verb@str()@ performs a similar but more
-user-friendly conversion.
-\bifuncindex{repr}
-\bifuncindex{str}
-
-\section{Primaries} \label{primaries}
-\index{primary}
-
-Primaries represent the most tightly bound operations of the language.
-Their syntax is:
-
-\begin{verbatim}
-primary:        atom | attributeref | subscription | slicing | call
-\end{verbatim}
-
-\subsection{Attribute references}
-\indexii{attribute}{reference}
-
-An attribute reference is a primary followed by a period and a name:
-
-\begin{verbatim}
-attributeref:   primary "." identifier
-\end{verbatim}
-
-The primary must evaluate to an object of a type that supports
-attribute references, e.g. a module or a list.  This object is then
-asked to produce the attribute whose name is the identifier.  If this
-attribute is not available, the exception \verb@AttributeError@ is
-raised.  Otherwise, the type and value of the object produced is
-determined by the object.  Multiple evaluations of the same attribute
-reference may yield different objects.
-\obindex{module}
-\obindex{list}
-
-\subsection{Subscriptions}
-\index{subscription}
-
-A subscription selects an item of a sequence (string, tuple or list)
-or mapping (dictionary) object:
-\obindex{sequence}
-\obindex{mapping}
-\obindex{string}
-\obindex{tuple}
-\obindex{list}
-\obindex{dictionary}
-\indexii{sequence}{item}
-
-\begin{verbatim}
-subscription:   primary "[" condition "]"
-\end{verbatim}
-
-The primary must evaluate to an object of a sequence or mapping type.
-
-If it is a mapping, the condition must evaluate to an object whose
-value is one of the keys of the mapping, and the subscription selects
-the value in the mapping that corresponds to that key.
-
-If it is a sequence, the condition must evaluate to a plain integer.
-If this value is negative, the length of the sequence is added to it
-(so that, e.g. \verb@x[-1]@ selects the last item of \verb@x@.)
-The resulting value must be a nonnegative integer smaller than the
-number of items in the sequence, and the subscription selects the item
-whose index is that value (counting from zero).
-
-A string's items are characters.  A character is not a separate data
-type but a string of exactly one character.
-\index{character}
-\indexii{string}{item}
-
-\subsection{Slicings}
-\index{slicing}
-\index{slice}
-
-A slicing (or slice) selects a range of items in a sequence (string,
-tuple or list) object:
-\obindex{sequence}
-\obindex{string}
-\obindex{tuple}
-\obindex{list}
-
-\begin{verbatim}
-slicing:        primary "[" [condition] ":" [condition] "]"
-\end{verbatim}
-
-The primary must evaluate to a sequence object.  The lower and upper
-bound expressions, if present, must evaluate to plain integers;
-defaults are zero and the sequence's length, respectively.  If either
-bound is negative, the sequence's length is added to it.  The slicing
-now selects all items with index \var{k} such that
-\code{\var{i} <= \var{k} < \var{j}} where \var{i}
-and \var{j} are the specified lower and upper bounds.  This may be an
-empty sequence.  It is not an error if \var{i} or \var{j} lie outside the
-range of valid indexes (such items don't exist so they aren't
-selected).
-
-\subsection{Calls} \label{calls}
-\index{call}
-
-A call calls a callable object (e.g. a function) with a possibly empty
-series of arguments:\footnote{The new syntax for keyword arguments is
-not yet documented in this manual.  See chapter 12 of the Tutorial.}
-\obindex{callable}
-
-\begin{verbatim}
-call:           primary "(" [condition_list] ")"
-\end{verbatim}
-
-The primary must evaluate to a callable object (user-defined
-functions, built-in functions, methods of built-in objects, class
-objects, and methods of class instances are callable).  If it is a
-class, the argument list must be empty; otherwise, the arguments are
-evaluated.
-
-A call always returns some value, possibly \verb@None@, unless it
-raises an exception.  How this value is computed depends on the type
-of the callable object.  If it is:
-
-\begin{description}
-
-\item[a user-defined function:] the code block for the function is
-executed, passing it the argument list.  The first thing the code
-block will do is bind the formal parameters to the arguments; this is
-described in section \ref{function}.  When the code block executes a
-\verb@return@ statement, this specifies the return value of the
-function call.
-\indexii{function}{call}
-\indexiii{user-defined}{function}{call}
-\obindex{user-defined function}
-\obindex{function}
-
-\item[a built-in function or method:] the result is up to the
-interpreter; see the library reference manual for the descriptions of
-built-in functions and methods.
-\indexii{function}{call}
-\indexii{built-in function}{call}
-\indexii{method}{call}
-\indexii{built-in method}{call}
-\obindex{built-in method}
-\obindex{built-in function}
-\obindex{method}
-\obindex{function}
-
-\item[a class object:] a new instance of that class is returned.
-\obindex{class}
-\indexii{class object}{call}
-
-\item[a class instance method:] the corresponding user-defined
-function is called, with an argument list that is one longer than the
-argument list of the call: the instance becomes the first argument.
-\obindex{class instance}
-\obindex{instance}
-\indexii{instance}{call}
-\indexii{class instance}{call}
-
-\end{description}
-
-\section{Unary arithmetic operations}
-\indexiii{unary}{arithmetic}{operation}
-\indexiii{unary}{bit-wise}{operation}
-
-All unary arithmetic (and bit-wise) operations have the same priority:
-
-\begin{verbatim}
-u_expr:         primary | "-" u_expr | "+" u_expr | "~" u_expr
-\end{verbatim}
-
-The unary \verb@"-"@ (minus) operator yields the negation of its
-numeric argument.
-\index{negation}
-\index{minus}
-
-The unary \verb@"+"@ (plus) operator yields its numeric argument
-unchanged.
-\index{plus}
-
-The unary \verb@"~"@ (invert) operator yields the bit-wise inversion
-of its plain or long integer argument.  The bit-wise inversion of
-\verb@x@ is defined as \verb@-(x+1)@.
-\index{inversion}
-
-In all three cases, if the argument does not have the proper type,
-a \verb@TypeError@ exception is raised.
-\exindex{TypeError}
-
-\section{Binary arithmetic operations}
-\indexiii{binary}{arithmetic}{operation}
-
-The binary arithmetic operations have the conventional priority
-levels.  Note that some of these operations also apply to certain
-non-numeric types.  There is no ``power'' operator, so there are only
-two levels, one for multiplicative operators and one for additive
-operators:
-
-\begin{verbatim}
-m_expr:         u_expr | m_expr "*" u_expr
-              | m_expr "/" u_expr | m_expr "%" u_expr
-a_expr:         m_expr | aexpr "+" m_expr | aexpr "-" m_expr
-\end{verbatim}
-
-The \verb@"*"@ (multiplication) operator yields the product of its
-arguments.  The arguments must either both be numbers, or one argument
-must be a plain integer and the other must be a sequence.  In the
-former case, the numbers are converted to a common type and then
-multiplied together.  In the latter case, sequence repetition is
-performed; a negative repetition factor yields an empty sequence.
-\index{multiplication}
-
-The \verb@"/"@ (division) operator yields the quotient of its
-arguments.  The numeric arguments are first converted to a common
-type.  Plain or long integer division yields an integer of the same
-type; the result is that of mathematical division with the `floor'
-function applied to the result.  Division by zero raises the
-\verb@ZeroDivisionError@ exception.
-\exindex{ZeroDivisionError}
-\index{division}
-
-The \verb@"%"@ (modulo) operator yields the remainder from the
-division of the first argument by the second.  The numeric arguments
-are first converted to a common type.  A zero right argument raises
-the \verb@ZeroDivisionError@ exception.  The arguments may be floating
-point numbers, e.g. \verb@3.14 % 0.7@ equals \verb@0.34@.  The modulo
-operator always yields a result with the same sign as its second
-operand (or zero); the absolute value of the result is strictly
-smaller than the second operand.
-\index{modulo}
-
-The integer division and modulo operators are connected by the
-following identity: \verb@x == (x/y)*y + (x%y)@.  Integer division and
-modulo are also connected with the built-in function \verb@divmod()@:
-\verb@divmod(x, y) == (x/y, x%y)@.  These identities don't hold for
-floating point numbers; there a similar identity holds where
-\verb@x/y@ is replaced by \verb@floor(x/y)@).
-
-The \verb@"+"@ (addition) operator yields the sum of its arguments.
-The arguments must either both be numbers, or both sequences of the
-same type.  In the former case, the numbers are converted to a common
-type and then added together.  In the latter case, the sequences are
-concatenated.
-\index{addition}
-
-The \verb@"-"@ (subtraction) operator yields the difference of its
-arguments.  The numeric arguments are first converted to a common
-type.
-\index{subtraction}
-
-\section{Shifting operations}
-\indexii{shifting}{operation}
-
-The shifting operations have lower priority than the arithmetic
-operations:
-
-\begin{verbatim}
-shift_expr:     a_expr | shift_expr ( "<<" | ">>" ) a_expr
-\end{verbatim}
-
-These operators accept plain or long integers as arguments.  The
-arguments are converted to a common type.  They shift the first
-argument to the left or right by the number of bits given by the
-second argument.
-
-A right shift by \var{n} bits is defined as division by
-\code{pow(2,\var{n})}.  A left shift by \var{n} bits is defined as
-multiplication with \code{pow(2,\var{n})}; for plain integers there is
-no overflow check so this drops bits and flips the sign if the result
-is not less than \code{pow(2,31)} in absolute value.
-
-Negative shift counts raise a \verb@ValueError@ exception.
-\exindex{ValueError}
-
-\section{Binary bit-wise operations}
-\indexiii{binary}{bit-wise}{operation}
-
-Each of the three bitwise operations has a different priority level:
-
-\begin{verbatim}
-and_expr:       shift_expr | and_expr "&" shift_expr
-xor_expr:       and_expr | xor_expr "^" and_expr
-or_expr:       xor_expr | or_expr "|" xor_expr
-\end{verbatim}
-
-The \verb@"&"@ operator yields the bitwise AND of its arguments, which
-must be plain or long integers.  The arguments are converted to a
-common type.
-\indexii{bit-wise}{and}
-
-The \verb@"^"@ operator yields the bitwise XOR (exclusive OR) of its
-arguments, which must be plain or long integers.  The arguments are
-converted to a common type.
-\indexii{bit-wise}{xor}
-\indexii{exclusive}{or}
-
-The \verb@"|"@ operator yields the bitwise (inclusive) OR of its
-arguments, which must be plain or long integers.  The arguments are
-converted to a common type.
-\indexii{bit-wise}{or}
-\indexii{inclusive}{or}
-
-\section{Comparisons}
-\index{comparison}
-
-Contrary to C, all comparison operations in Python have the same
-priority, which is lower than that of any arithmetic, shifting or
-bitwise operation.  Also contrary to C, expressions like
-\verb@a < b < c@ have the interpretation that is conventional in
-mathematics:
-\index{C}
-
-\begin{verbatim}
-comparison:     or_expr (comp_operator or_expr)*
-comp_operator:  "<"|">"|"=="|">="|"<="|"<>"|"!="|"is" ["not"]|["not"] "in"
-\end{verbatim}
-
-Comparisons yield integer values: 1 for true, 0 for false.
-
-Comparisons can be chained arbitrarily, e.g. \code{x < y <= z} is
-equivalent to \code{x < y and y <= z}, except that \code{y} is
-evaluated only once (but in both cases \code{z} is not evaluated at all
-when \code{x < y} is found to be false).
-\indexii{chaining}{comparisons}
-
-Formally, if \var{a}, \var{b}, \var{c}, \ldots, \var{y}, \var{z} are
-expressions and \var{opa}, \var{opb}, \ldots, \var{opy} are comparison
-operators, then \var{a opa b opb c} \ldots \var{y opy z} is equivalent
-to \var{a opa b} \code{and} \var{b opb c} \code{and} \ldots \code{and}
-\var{y opy z}, except that each expression is evaluated at most once.
-
-Note that \var{a opa b opb c} doesn't imply any kind of comparison
-between \var{a} and \var{c}, so that e.g.\ \code{x < y > z} is
-perfectly legal (though perhaps not pretty).
-
-The forms \verb@<>@ and \verb@!=@ are equivalent; for consistency with
-C, \verb@!=@ is preferred; where \verb@!=@ is mentioned below
-\verb@<>@ is also implied.
-
-The operators {\tt "<", ">", "==", ">=", "<="}, and {\tt "!="} compare
-the values of two objects.  The objects needn't have the same type.
-If both are numbers, they are coverted to a common type.  Otherwise,
-objects of different types {\em always} compare unequal, and are
-ordered consistently but arbitrarily.
-
-(This unusual definition of comparison is done to simplify the
-definition of operations like sorting and the \verb@in@ and
-\verb@not@ \verb@in@ operators.)
-
-Comparison of objects of the same type depends on the type:
-
-\begin{itemize}
-
-\item
-Numbers are compared arithmetically.
-
-\item
-Strings are compared lexicographically using the numeric equivalents
-(the result of the built-in function \verb@ord@) of their characters.
-
-\item
-Tuples and lists are compared lexicographically using comparison of
-corresponding items.
-
-\item
-Mappings (dictionaries) are compared through lexicographic
-comparison of their sorted (key, value) lists.%
-\footnote{This is expensive since it requires sorting the keys first,
-but about the only sensible definition.  An earlier version of Python
-compared dictionaries by identity only, but this caused surprises
-because people expected to be able to test a dictionary for emptiness
-by comparing it to {\tt \{\}}.}
-
-\item
-Most other types compare unequal unless they are the same object;
-the choice whether one object is considered smaller or larger than
-another one is made arbitrarily but consistently within one
-execution of a program.
-
-\end{itemize}
-
-The operators \verb@in@ and \verb@not in@ test for sequence
-membership: if \var{y} is a sequence, \code{\var{x} in \var{y}} is
-true if and only if there exists an index \var{i} such that
-\code{\var{x} = \var{y}[\var{i}]}.
-\code{\var{x} not in \var{y}} yields the inverse truth value.  The
-exception \verb@TypeError@ is raised when \var{y} is not a sequence,
-or when \var{y} is a string and \var{x} is not a string of length one.%
-\footnote{The latter restriction is sometimes a nuisance.}
-\opindex{in}
-\opindex{not in}
-\indexii{membership}{test}
-\obindex{sequence}
-
-The operators \verb@is@ and \verb@is not@ test for object identity:
-\var{x} \code{is} \var{y} is true if and only if \var{x} and \var{y}
-are the same object.  \var{x} \code{is not} \var{y} yields the inverse
-truth value.
-\opindex{is}
-\opindex{is not}
-\indexii{identity}{test}
-
-\section{Boolean operations} \label{Booleans}
-\indexii{Boolean}{operation}
-
-Boolean operations have the lowest priority of all Python operations:
-
-\begin{verbatim}
-condition:      or_test | lambda_form
-or_test:        and_test | or_test "or" and_test
-and_test:       not_test | and_test "and" not_test
-not_test:       comparison | "not" not_test
-lambda_form:	"lambda" [parameter_list]: condition
-\end{verbatim}
-
-In the context of Boolean operations, and also when conditions are
-used by control flow statements, the following values are interpreted
-as false: \verb@None@, numeric zero of all types, empty sequences
-(strings, tuples and lists), and empty mappings (dictionaries).  All
-other values are interpreted as true.
-
-The operator \verb@not@ yields 1 if its argument is false, 0 otherwise.
-\opindex{not}
-
-The condition \var{x} \verb@and@ \var{y} first evaluates \var{x}; if
-\var{x} is false, its value is returned; otherwise, \var{y} is
-evaluated and the resulting value is returned.
-\opindex{and}
-
-The condition \var{x} \verb@or@ \var{y} first evaluates \var{x}; if
-\var{x} is true, its value is returned; otherwise, \var{y} is
-evaluated and the resulting value is returned.
-\opindex{or}
-
-(Note that \verb@and@ and \verb@or@ do not restrict the value and type
-they return to 0 and 1, but rather return the last evaluated argument.
-This is sometimes useful, e.g. if \verb@s@ is a string that should be
-replaced by a default value if it is empty, the expression
-\verb@s or 'foo'@ yields the desired value.  Because \verb@not@ has to
-invent a value anyway, it does not bother to return a value of the
-same type as its argument, so e.g. \verb@not 'foo'@ yields \verb@0@,
-not \verb@''@.)
-
-Lambda forms (lambda expressions) have the same syntactic position as
-conditions.  They are a shorthand to create anonymous functions; the
-expression {\em {\tt lambda} arguments{\tt :} condition}
-yields a function object that behaves virtually identical to one
-defined with
-{\em {\tt def} name {\tt (}arguments{\tt ): return} condition}.
-See section \ref{function} for the syntax of
-parameter lists.  Note that functions created with lambda forms cannot
-contain statements.
-\label{lambda}
-\indexii{lambda}{expression}
-\indexii{lambda}{form}
-\indexii{anonmymous}{function}
-
-\section{Expression lists and condition lists}
-\indexii{expression}{list}
-\indexii{condition}{list}
-
-\begin{verbatim}
-expression_list:      or_expr ("," or_expr)* [","]
-condintion_list:      condition ("," condition)* [","]
-\end{verbatim}
-
-The only difference between expression lists and condition lists is
-the lowest priority of operators that can be used in them without
-being enclosed in parentheses; condition lists allow all operators,
-while expression lists don't allow comparisons and Boolean operators
-(they do allow bitwise and shift operators though).
-
-Expression lists are used in expression statements and assignments;
-condition lists are used everywhere else where a list of
-comma-separated values is required.
-
-An expression (condition) list containing at least one comma yields a
-tuple.  The length of the tuple is the number of expressions
-(conditions) in the list.  The expressions (conditions) are evaluated
-from left to right.  (Condition lists are used syntactically is a few
-places where no tuple is constructed but a list of values is needed
-nevertheless.)
-\obindex{tuple}
-
-The trailing comma is required only to create a single tuple (a.k.a. a
-{\em singleton}); it is optional in all other cases.  A single
-expression (condition) without a trailing comma doesn't create a
-tuple, but rather yields the value of that expression (condition).
-\indexii{trailing}{comma}
-
-(To create an empty tuple, use an empty pair of parentheses:
-\verb@()@.)
-
-\section{Summary}
-
-The following table summarizes the operator precedences in Python,
-from lowest precedence (least binding) to highest precedence (most
-binding).  Operators in the same box have the same precedence.  Unless
-the syntax is explicitly given, operators are binary.  Operators in
-the same box group left to right (except for comparisons, which
-chain from left to right --- see above).
-
-\begin{center}
-\begin{tabular}{|c|c|}
-\hline
-\code{or} & Boolean OR \\
-\hline
-\code{and} & Boolean AND \\
-\hline
-\code{not} \var{x} & Boolean NOT \\
-\hline
-\code{in}, \code{not} \code{in} & Membership tests \\
-\code{is}, \code{is} \code{not} & Identity tests \\
-\code{<}, \code{<=}, \code{>}, \code{>=}, \code{<>}, \code{!=}, \code{=} &
-	Comparisons \\
-\hline
-\code{|} & Bitwise OR \\
-\hline
-\code{\^} & Bitwise XOR \\
-\hline
-\code{\&} & Bitwise AND \\
-\hline
-\code{<<}, \code{>>} & Shifts \\
-\hline
-\code{+}, \code{-} & Addition and subtraction \\
-\hline
-\code{*}, \code{/}, \code{\%} & Multiplication, division, remainder \\
-\hline
-\code{+\var{x}}, \code{-\var{x}} & Positive, negative \\
-\code{\~\var{x}} & Bitwise not \\
-\hline
-\code{\var{x}.\var{attribute}} & Attribute reference \\
-\code{\var{x}[\var{index}]} &  Subscription \\
-\code{\var{x}[\var{index}:\var{index}]} &  Slicing \\
-\code{\var{f}(\var{arguments}...)} & Function call \\
-\hline
-\code{(\var{expressions}\ldots)} & Binding or tuple display \\
-\code{[\var{expressions}\ldots]} & List display \\
-\code{\{\var{key}:\var{datum}\ldots\}} & Dictionary display \\
-\code{`\var{expression}\ldots`} & String conversion \\
-\hline
-\end{tabular}
-\end{center}
diff --git a/Doc/ref6.tex b/Doc/ref6.tex
deleted file mode 100644
index 5bd468c..0000000
--- a/Doc/ref6.tex
+++ /dev/null
@@ -1,512 +0,0 @@
-\chapter{Simple statements}
-\indexii{simple}{statement}
-
-Simple statements are comprised within a single logical line.
-Several simple statements may occur on a single line separated
-by semicolons.  The syntax for simple statements is:
-
-\begin{verbatim}
-simple_stmt:    expression_stmt
-              | assignment_stmt
-              | pass_stmt
-              | del_stmt
-              | print_stmt
-              | return_stmt
-              | raise_stmt
-              | break_stmt
-              | continue_stmt
-              | import_stmt
-              | global_stmt
-              | exec_stmt
-\end{verbatim}
-
-\section{Expression statements}
-\indexii{expression}{statement}
-
-Expression statements are used (mostly interactively) to compute and
-write a value, or (usually) to call a procedure (a function that
-returns no meaningful result; in Python, procedures return the value
-\verb@None@):
-
-\begin{verbatim}
-expression_stmt: condition_list
-\end{verbatim}
-
-An expression statement evaluates the condition list (which may be a
-single condition).
-\indexii{expression}{list}
-
-In interactive mode, if the value is not \verb@None@, it is converted
-to a string using the rules for string conversions (expressions in
-reverse quotes), and the resulting string is written to standard
-output (see section \ref{print}) on a line by itself.
-(The exception for \verb@None@ is made so that procedure calls, which
-are syntactically equivalent to expressions, do not cause any output.)
-\ttindex{None}
-\indexii{string}{conversion}
-\index{output}
-\indexii{standard}{output}
-\indexii{writing}{values}
-\indexii{procedure}{call}
-
-\section{Assignment statements}
-\indexii{assignment}{statement}
-
-Assignment statements are used to (re)bind names to values and to
-modify attributes or items of mutable objects:
-\indexii{binding}{name}
-\indexii{rebinding}{name}
-\obindex{mutable}
-\indexii{attribute}{assignment}
-
-\begin{verbatim}
-assignment_stmt: (target_list "=")+ expression_list
-target_list:     target ("," target)* [","]
-target:          identifier | "(" target_list ")" | "[" target_list "]"
-               | attributeref | subscription | slicing
-\end{verbatim}
-
-(See section \ref{primaries} for the syntax definitions for the last
-three symbols.)
-
-An assignment statement evaluates the expression list (remember that
-this can be a single expression or a comma-separated list, the latter
-yielding a tuple) and assigns the single resulting object to each of
-the target lists, from left to right.
-\indexii{expression}{list}
-
-Assignment is defined recursively depending on the form of the target
-(list).  When a target is part of a mutable object (an attribute
-reference, subscription or slicing), the mutable object must
-ultimately perform the assignment and decide about its validity, and
-may raise an exception if the assignment is unacceptable.  The rules
-observed by various types and the exceptions raised are given with the
-definition of the object types (see section \ref{types}).
-\index{target}
-\indexii{target}{list}
-
-Assignment of an object to a target list is recursively defined as
-follows.
-\indexiii{target}{list}{assignment}
-
-\begin{itemize}
-\item
-If the target list is a single target: the object is assigned to that
-target.
-
-\item
-If the target list is a comma-separated list of targets: the object
-must be a tuple with the same number of items as the list contains
-targets, and the items are assigned, from left to right, to the
-corresponding targets.
-
-\end{itemize}
-
-Assignment of an object to a single target is recursively defined as
-follows.
-
-\begin{itemize} % nested
-
-\item
-If the target is an identifier (name):
-
-\begin{itemize}
-
-\item
-If the name does not occur in a \verb@global@ statement in the current
-code block: the name is bound to the object in the current local name
-space.
-\stindex{global}
-
-\item
-Otherwise: the name is bound to the object in the current global name
-space.
-
-\end{itemize} % nested
-
-The name is rebound if it was already bound.
-
-\item
-If the target is a target list enclosed in parentheses: the object is
-assigned to that target list as described above.
-
-\item
-If the target is a target list enclosed in square brackets: the object
-must be a list with the same number of items as the target list
-contains targets, and its items are assigned, from left to right, to
-the corresponding targets.
-
-\item
-If the target is an attribute reference: The primary expression in the
-reference is evaluated.  It should yield an object with assignable
-attributes; if this is not the case, \verb@TypeError@ is raised.  That
-object is then asked to assign the assigned object to the given
-attribute; if it cannot perform the assignment, it raises an exception
-(usually but not necessarily \verb@AttributeError@).
-\indexii{attribute}{assignment}
-
-\item
-If the target is a subscription: The primary expression in the
-reference is evaluated.  It should yield either a mutable sequence
-(list) object or a mapping (dictionary) object.  Next, the subscript
-expression is evaluated.
-\indexii{subscription}{assignment}
-\obindex{mutable}
-
-If the primary is a mutable sequence object (a list), the subscript
-must yield a plain integer.  If it is negative, the sequence's length
-is added to it.  The resulting value must be a nonnegative integer
-less than the sequence's length, and the sequence is asked to assign
-the assigned object to its item with that index.  If the index is out
-of range, \verb@IndexError@ is raised (assignment to a subscripted
-sequence cannot add new items to a list).
-\obindex{sequence}
-\obindex{list}
-
-If the primary is a mapping (dictionary) object, the subscript must
-have a type compatible with the mapping's key type, and the mapping is
-then asked to create a key/datum pair which maps the subscript to
-the assigned object.  This can either replace an existing key/value
-pair with the same key value, or insert a new key/value pair (if no
-key with the same value existed).
-\obindex{mapping}
-\obindex{dictionary}
-
-\item
-If the target is a slicing: The primary expression in the reference is
-evaluated.  It should yield a mutable sequence object (e.g. a list).  The
-assigned object should be a sequence object of the same type.  Next,
-the lower and upper bound expressions are evaluated, insofar they are
-present; defaults are zero and the sequence's length.  The bounds
-should evaluate to (small) integers.  If either bound is negative, the
-sequence's length is added to it.  The resulting bounds are clipped to
-lie between zero and the sequence's length, inclusive.  Finally, the
-sequence object is asked to replace the slice with the items of the
-assigned sequence.  The length of the slice may be different from the
-length of the assigned sequence, thus changing the length of the
-target sequence, if the object allows it.
-\indexii{slicing}{assignment}
-
-\end{itemize}
-	
-(In the current implementation, the syntax for targets is taken
-to be the same as for expressions, and invalid syntax is rejected
-during the code generation phase, causing less detailed error
-messages.)
-
-WARNING: Although the definition of assignment implies that overlaps
-between the left-hand side and the right-hand side are `safe' (e.g.
-\verb@a, b = b, a@ swaps two variables), overlaps within the
-collection of assigned-to variables are not safe!  For instance, the
-following program prints \code@[0, 2]@:
-
-\begin{verbatim}
-x = [0, 1]
-i = 0
-i, x[i] = 1, 2
-print x
-\end{verbatim}
-
-
-\section{The {\tt pass} statement}
-\stindex{pass}
-
-\begin{verbatim}
-pass_stmt:      "pass"
-\end{verbatim}
-
-\verb@pass@ is a null operation --- when it is executed, nothing
-happens.  It is useful as a placeholder when a statement is
-required syntactically, but no code needs to be executed, for example:
-\indexii{null}{operation}
-
-\begin{verbatim}
-def f(arg): pass    # a function that does nothing (yet)
-
-class C: pass       # a class with no methods (yet)
-\end{verbatim}
-
-\section{The {\tt del} statement}
-\stindex{del}
-
-\begin{verbatim}
-del_stmt:       "del" target_list
-\end{verbatim}
-
-Deletion is recursively defined very similar to the way assignment is
-defined. Rather that spelling it out in full details, here are some
-hints.
-\indexii{deletion}{target}
-\indexiii{deletion}{target}{list}
-
-Deletion of a target list recursively deletes each target, from left
-to right.
-
-Deletion of a name removes the binding of that name (which must exist)
-from the local or global name space, depending on whether the name
-occurs in a \verb@global@ statement in the same code block.
-\stindex{global}
-\indexii{unbinding}{name}
-
-Deletion of attribute references, subscriptions and slicings
-is passed to the primary object involved; deletion of a slicing
-is in general equivalent to assignment of an empty slice of the
-right type (but even this is determined by the sliced object).
-\indexii{attribute}{deletion}
-
-\section{The {\tt print} statement} \label{print}
-\stindex{print}
-
-\begin{verbatim}
-print_stmt:     "print" [ condition ("," condition)* [","] ]
-\end{verbatim}
-
-\verb@print@ evaluates each condition in turn and writes the resulting
-object to standard output (see below).  If an object is not a string,
-it is first converted to a string using the rules for string
-conversions.  The (resulting or original) string is then written.  A
-space is written before each object is (converted and) written, unless
-the output system believes it is positioned at the beginning of a
-line.  This is the case: (1) when no characters have yet been written
-to standard output; or (2) when the last character written to standard
-output is \verb/\n/; or (3) when the last write operation on standard
-output was not a \verb@print@ statement.  (In some cases it may be
-functional to write an empty string to standard output for this
-reason.)
-\index{output}
-\indexii{writing}{values}
-
-A \verb/"\n"/ character is written at the end, unless the \verb@print@
-statement ends with a comma.  This is the only action if the statement
-contains just the keyword \verb@print@.
-\indexii{trailing}{comma}
-\indexii{newline}{suppression}
-
-Standard output is defined as the file object named \verb@stdout@
-in the built-in module \verb@sys@.  If no such object exists,
-or if it is not a writable file, a \verb@RuntimeError@ exception is raised.
-(The original implementation attempts to write to the system's original
-standard output instead, but this is not safe, and should be fixed.)
-\indexii{standard}{output}
-\bimodindex{sys}
-\ttindex{stdout}
-\exindex{RuntimeError}
-
-\section{The {\tt return} statement}
-\stindex{return}
-
-\begin{verbatim}
-return_stmt:    "return" [condition_list]
-\end{verbatim}
-
-\verb@return@ may only occur syntactically nested in a function
-definition, not within a nested class definition.
-\indexii{function}{definition}
-\indexii{class}{definition}
-
-If a condition list is present, it is evaluated, else \verb@None@
-is substituted.
-
-\verb@return@ leaves the current function call with the condition
-list (or \verb@None@) as return value.
-
-When \verb@return@ passes control out of a \verb@try@ statement
-with a \verb@finally@ clause, that finally clause is executed
-before really leaving the function.
-\kwindex{finally}
-
-\section{The {\tt raise} statement}
-\stindex{raise}
-
-\begin{verbatim}
-raise_stmt:     "raise" condition ["," condition ["," condition]]
-\end{verbatim}
-
-\verb@raise@ evaluates its first condition, which must yield
-a string, class, or instance object.  If there is a second condition,
-this is evaluated, else \verb@None@ is substituted.  If the first
-condition is a class object, then the second condition must be an
-instance of that class or one of its derivatives.  If the first
-condition is an instance object, the second condition must be
-\verb@None@.
-\index{exception}
-\indexii{raising}{exception}
-
-If the first object is a class or string, it then raises the exception
-identified by the first object, with the second one (or \verb@None@)
-as its parameter.  If the first object is an instance, it raises the
-exception identified by the class of the object, with the instance as
-its parameter (and there should be no second object, or the second
-object should be \verb@None@).
-
-If a third object is present, and it it not \verb@None@, it should be
-a traceback object (see section \ref{traceback}), and it is
-substituted instead of the current location as the place where the
-exception occurred.  This is useful to re-raise an exception
-transparently in an except clause.
-\obindex{traceback}
-
-\section{The {\tt break} statement}
-\stindex{break}
-
-\begin{verbatim}
-break_stmt:     "break"
-\end{verbatim}
-
-\verb@break@ may only occur syntactically nested in a \verb@for@
-or \verb@while@ loop, but not nested in a function or class definition
-within that loop.
-\stindex{for}
-\stindex{while}
-\indexii{loop}{statement}
-
-It terminates the nearest enclosing loop, skipping the optional
-\verb@else@ clause if the loop has one.
-\kwindex{else}
-
-If a \verb@for@ loop is terminated by \verb@break@, the loop control
-target keeps its current value.
-\indexii{loop control}{target}
-
-When \verb@break@ passes control out of a \verb@try@ statement
-with a \verb@finally@ clause, that finally clause is executed
-before really leaving the loop.
-\kwindex{finally}
-
-\section{The {\tt continue} statement}
-\stindex{continue}
-
-\begin{verbatim}
-continue_stmt:  "continue"
-\end{verbatim}
-
-\verb@continue@ may only occur syntactically nested in a \verb@for@ or
-\verb@while@ loop, but not nested in a function or class definition or
-\verb@try@ statement within that loop.\footnote{Except that it may
-currently occur within an {\tt except} clause.}
-\stindex{for}
-\stindex{while}
-\indexii{loop}{statement}
-\kwindex{finally}
-
-It continues with the next cycle of the nearest enclosing loop.
-
-\section{The {\tt import} statement} \label{import}
-\stindex{import}
-
-\begin{verbatim}
-import_stmt:    "import" identifier ("," identifier)*
-              | "from" identifier "import" identifier ("," identifier)*
-              | "from" identifier "import" "*"
-\end{verbatim}
-
-Import statements are executed in two steps: (1) find a module, and
-initialize it if necessary; (2) define a name or names in the local
-name space (of the scope where the \verb@import@ statement occurs).
-The first form (without \verb@from@) repeats these steps for each
-identifier in the list, the \verb@from@ form performs them once, with
-the first identifier specifying the module name.
-\indexii{importing}{module}
-\indexii{name}{binding}
-\kwindex{from}
-
-The system maintains a table of modules that have been initialized,
-indexed by module name.  (The current implementation makes this table
-accessible as \verb@sys.modules@.)  When a module name is found in
-this table, step (1) is finished.  If not, a search for a module
-definition is started.  This first looks for a built-in module
-definition, and if no built-in module if the given name is found, it
-searches a user-specified list of directories for a file whose name is
-the module name with extension \verb@".py"@.  (The current
-implementation uses the list of strings \verb@sys.path@ as the search
-path; it is initialized from the shell environment variable
-\verb@$PYTHONPATH@, with an installation-dependent default.)
-\ttindex{modules}
-\ttindex{sys.modules}
-\indexii{module}{name}
-\indexii{built-in}{module}
-\indexii{user-defined}{module}
-\bimodindex{sys}
-\ttindex{path}
-\ttindex{sys.path}
-\indexii{filename}{extension}
-
-If a built-in module is found, its built-in initialization code is
-executed and step (1) is finished.  If no matching file is found,
-\verb@ImportError@ is raised.  If a file is found, it is parsed,
-yielding an executable code block.  If a syntax error occurs,
-\verb@SyntaxError@ is raised.  Otherwise, an empty module of the given
-name is created and inserted in the module table, and then the code
-block is executed in the context of this module.  Exceptions during
-this execution terminate step (1).
-\indexii{module}{initialization}
-\exindex{SyntaxError}
-\exindex{ImportError}
-\index{code block}
-
-When step (1) finishes without raising an exception, step (2) can
-begin.
-
-The first form of \verb@import@ statement binds the module name in the
-local name space to the module object, and then goes on to import the
-next identifier, if any.  The \verb@from@ from does not bind the
-module name: it goes through the list of identifiers, looks each one
-of them up in the module found in step (1), and binds the name in the
-local name space to the object thus found.  If a name is not found,
-\verb@ImportError@ is raised.  If the list of identifiers is replaced
-by a star (\verb@*@), all names defined in the module are bound,
-except those beginning with an underscore(\verb@_@).
-\indexii{name}{binding}
-\exindex{ImportError}
-
-Names bound by import statements may not occur in \verb@global@
-statements in the same scope.
-\stindex{global}
-
-The \verb@from@ form with \verb@*@ may only occur in a module scope.
-\kwindex{from}
-\ttindex{from ... import *}
-
-(The current implementation does not enforce the latter two
-restrictions, but programs should not abuse this freedom, as future
-implementations may enforce them or silently change the meaning of the
-program.)
-
-\section{The {\tt global} statement} \label{global}
-\stindex{global}
-
-\begin{verbatim}
-global_stmt:    "global" identifier ("," identifier)*
-\end{verbatim}
-
-The \verb@global@ statement is a declaration which holds for the
-entire current code block.  It means that the listed identifiers are to be
-interpreted as globals.  While {\em using} global names is automatic
-if they are not defined in the local scope, {\em assigning} to global
-names would be impossible without \verb@global@.
-\indexiii{global}{name}{binding}
-
-Names listed in a \verb@global@ statement must not be used in the same
-code block before that \verb@global@ statement is executed.
-
-Names listed in a \verb@global@ statement must not be defined as formal
-parameters or in a \verb@for@ loop control target, \verb@class@
-definition, function definition, or \verb@import@ statement.
-
-(The current implementation does not enforce the latter two
-restrictions, but programs should not abuse this freedom, as future
-implementations may enforce them or silently change the meaning of the
-program.)
-
-Note: the \verb@global@ is a directive to the parser.  Therefore, it
-applies only to code parsed at the same time as the \verb@global@
-statement.  In particular, a \verb@global@ statement contained in an
-\verb@exec@ statement does not affect the code block {\em containing}
-the \verb@exec@ statement, and code contained in an \verb@exec@
-statement is unaffected by \verb@global@ statements in the code
-containing the \verb@exec@ statement.  The same applies to the
-\verb@eval()@, \verb@execfie()@ and \verb@compile()@ functions.
-\stindex{exec}
-\ttindex{eval}
-\ttindex{execfile}
-\ttindex{compile}
diff --git a/Doc/ref7.tex b/Doc/ref7.tex
deleted file mode 100644
index 9bce121..0000000
--- a/Doc/ref7.tex
+++ /dev/null
@@ -1,391 +0,0 @@
-\chapter{Compound statements}
-\indexii{compound}{statement}
-
-Compound statements contain (groups of) other statements; they affect
-or control the execution of those other statements in some way.  In
-general, compound statements span multiple lines, although in simple
-incarnations a whole compound statement may be contained in one line.
-
-The \verb@if@, \verb@while@ and \verb@for@ statements implement
-traditional control flow constructs.  \verb@try@ specifies exception
-handlers and/or cleanup code for a group of statements.  Function and
-class definitions are also syntactically compound statements.
-
-Compound statements consist of one or more `clauses'.  A clause
-consists of a header and a `suite'.  The clause headers of a
-particular compound statement are all at the same indentation level.
-Each clause header begins with a uniquely identifying keyword and ends
-with a colon.  A suite is a group of statements controlled by a
-clause.  A suite can be one or more semicolon-separated simple
-statements on the same line as the header, following the header's
-colon, or it can be one or more indented statements on subsequent
-lines.  Only the latter form of suite can contain nested compound
-statements; the following is illegal, mostly because it wouldn't be
-clear to which \verb@if@ clause a following \verb@else@ clause would
-belong:
-\index{clause}
-\index{suite}
-
-\begin{verbatim}
-if test1: if test2: print x
-\end{verbatim}
-
-Also note that the semicolon binds tighter than the colon in this
-context, so that in the following example, either all or none of the
-\verb@print@ statements are executed:
-
-\begin{verbatim}
-if x < y < z: print x; print y; print z
-\end{verbatim}
-
-Summarizing:
-
-\begin{verbatim}
-compound_stmt:  if_stmt | while_stmt | for_stmt
-              | try_stmt | funcdef | classdef
-suite:          stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
-statement:      stmt_list NEWLINE | compound_stmt
-stmt_list:      simple_stmt (";" simple_stmt)* [";"]
-\end{verbatim}
-
-Note that statements always end in a \verb@NEWLINE@ possibly followed
-by a \verb@DEDENT@.
-\index{NEWLINE token}
-\index{DEDENT token}
-
-Also note that optional continuation clauses always begin with a
-keyword that cannot start a statement, thus there are no ambiguities
-(the `dangling \verb@else@' problem is solved in Python by requiring
-nested \verb@if@ statements to be indented).
-\indexii{dangling}{else}
-
-The formatting of the grammar rules in the following sections places
-each clause on a separate line for clarity.
-
-\section{The {\tt if} statement}
-\stindex{if}
-
-The \verb@if@ statement is used for conditional execution:
-
-\begin{verbatim}
-if_stmt:        "if" condition ":" suite
-               ("elif" condition ":" suite)*
-               ["else" ":" suite]
-\end{verbatim}
-
-It selects exactly one of the suites by evaluating the conditions one
-by one until one is found to be true (see section \ref{Booleans} for
-the definition of true and false); then that suite is executed (and no
-other part of the \verb@if@ statement is executed or evaluated).  If
-all conditions are false, the suite of the \verb@else@ clause, if
-present, is executed.
-\kwindex{elif}
-\kwindex{else}
-
-\section{The {\tt while} statement}
-\stindex{while}
-\indexii{loop}{statement}
-
-The \verb@while@ statement is used for repeated execution as long as a
-condition is true:
-
-\begin{verbatim}
-while_stmt:     "while" condition ":" suite
-               ["else" ":" suite]
-\end{verbatim}
-
-This repeatedly tests the condition and, if it is true, executes the
-first suite; if the condition is false (which may be the first time it
-is tested) the suite of the \verb@else@ clause, if present, is
-executed and the loop terminates.
-\kwindex{else}
-
-A \verb@break@ statement executed in the first suite terminates the
-loop without executing the \verb@else@ clause's suite.  A
-\verb@continue@ statement executed in the first suite skips the rest
-of the suite and goes back to testing the condition.
-\stindex{break}
-\stindex{continue}
-
-\section{The {\tt for} statement}
-\stindex{for}
-\indexii{loop}{statement}
-
-The \verb@for@ statement is used to iterate over the elements of a
-sequence (string, tuple or list):
-\obindex{sequence}
-
-\begin{verbatim}
-for_stmt:       "for" target_list "in" condition_list ":" suite
-               ["else" ":" suite]
-\end{verbatim}
-
-The condition list is evaluated once; it should yield a sequence.  The
-suite is then executed once for each item in the sequence, in the
-order of ascending indices.  Each item in turn is assigned to the
-target list using the standard rules for assignments, and then the
-suite is executed.  When the items are exhausted (which is immediately
-when the sequence is empty), the suite in the \verb@else@ clause, if
-present, is executed, and the loop terminates.
-\kwindex{in}
-\kwindex{else}
-\indexii{target}{list}
-
-A \verb@break@ statement executed in the first suite terminates the
-loop without executing the \verb@else@ clause's suite.  A
-\verb@continue@ statement executed in the first suite skips the rest
-of the suite and continues with the next item, or with the \verb@else@
-clause if there was no next item.
-\stindex{break}
-\stindex{continue}
-
-The suite may assign to the variable(s) in the target list; this does
-not affect the next item assigned to it.
-
-The target list is not deleted when the loop is finished, but if the
-sequence is empty, it will not have been assigned to at all by the
-loop.
-
-Hint: the built-in function \verb@range()@ returns a sequence of
-integers suitable to emulate the effect of Pascal's
-\verb@for i := a to b do@;
-e.g. \verb@range(3)@ returns the list \verb@[0, 1, 2]@.
-\bifuncindex{range}
-\index{Pascal}
-
-{\bf Warning:} There is a subtlety when the sequence is being modified
-by the loop (this can only occur for mutable sequences, i.e. lists).
-An internal counter is used to keep track of which item is used next,
-and this is incremented on each iteration.  When this counter has
-reached the length of the sequence the loop terminates.  This means that
-if the suite deletes the current (or a previous) item from the
-sequence, the next item will be skipped (since it gets the index of
-the current item which has already been treated).  Likewise, if the
-suite inserts an item in the sequence before the current item, the
-current item will be treated again the next time through the loop.
-This can lead to nasty bugs that can be avoided by making a temporary
-copy using a slice of the whole sequence, e.g.
-\index{loop!over mutable sequence}
-\index{mutable sequence!loop over}
-
-\begin{verbatim}
-for x in a[:]:
-    if x < 0: a.remove(x)
-\end{verbatim}
-
-\section{The {\tt try} statement} \label{try}
-\stindex{try}
-
-The \verb@try@ statement specifies exception handlers and/or cleanup
-code for a group of statements:
-
-\begin{verbatim}
-try_stmt:       try_exc_stmt | try_fin_stmt
-try_exc_stmt:   "try" ":" suite
-               ("except" [condition ["," target]] ":" suite)+
-               ["else" ":" suite]
-try_fin_stmt:   "try" ":" suite
-               "finally" ":" suite
-\end{verbatim}
-
-There are two forms of \verb@try@ statement: \verb@try...except@ and
-\verb@try...finally@.  These forms cannot be mixed.
-
-The \verb@try...except@ form specifies one or more exception handlers
-(the \verb@except@ clauses).  When no exception occurs in the
-\verb@try@ clause, no exception handler is executed.  When an
-exception occurs in the \verb@try@ suite, a search for an exception
-handler is started.  This inspects the except clauses in turn until
-one is found that matches the exception.  A condition-less except
-clause, if present, must be last; it matches any exception.  For an
-except clause with a condition, that condition is evaluated, and the
-clause matches the exception if the resulting object is ``compatible''
-with the exception.  An object is compatible with an exception if it
-is either the object that identifies the exception, or (for exceptions
-that are classes) it is a base class of the exception, or it is a
-tuple containing an item that is compatible with the exception.  Note
-that the object identities must match, i.e. it must be the same
-object, not just an object with the same value.
-\kwindex{except}
-
-If no except clause matches the exception, the search for an exception
-handler continues in the surrounding code and on the invocation stack.
-
-If the evaluation of a condition in the header of an except clause
-raises an exception, the original search for a handler is cancelled
-and a search starts for the new exception in the surrounding code and
-on the call stack (it is treated as if the entire \verb@try@ statement
-raised the exception).
-
-When a matching except clause is found, the exception's parameter is
-assigned to the target specified in that except clause, if present,
-and the except clause's suite is executed.  When the end of this suite
-is reached, execution continues normally after the entire try
-statement.  (This means that if two nested handlers exist for the same
-exception, and the exception occurs in the try clause of the inner
-handler, the outer handler will not handle the exception.)
-
-Before an except clause's suite is executed, details about the
-exception are assigned to three variables in the \verb@sys@ module:
-\verb@sys.exc_type@ receives the object identifying the exception;
-\verb@sys.exc_value@ receives the exception's parameter;
-\verb@sys.exc_traceback@ receives a traceback object (see section
-\ref{traceback}) identifying the point in the program where the
-exception occurred.
-\bimodindex{sys}
-\ttindex{exc_type}
-\ttindex{exc_value}
-\ttindex{exc_traceback}
-\obindex{traceback}
-
-The optional \verb@else@ clause is executed when no exception occurs
-in the \verb@try@ clause.  Exceptions in the \verb@else@ clause are
-not handled by the preceding \verb@except@ clauses.
-\kwindex{else}
-
-The \verb@try...finally@ form specifies a `cleanup' handler.  The
-\verb@try@ clause is executed.  When no exception occurs, the
-\verb@finally@ clause is executed.  When an exception occurs in the
-\verb@try@ clause, the exception is temporarily saved, the
-\verb@finally@ clause is executed, and then the saved exception is
-re-raised.  If the \verb@finally@ clause raises another exception or
-executes a \verb@return@, \verb@break@ or \verb@continue@ statement,
-the saved exception is lost.
-\kwindex{finally}
-
-When a \verb@return@ or \verb@break@ statement is executed in the
-\verb@try@ suite of a \verb@try...finally@ statement, the
-\verb@finally@ clause is also executed `on the way out'.  A
-\verb@continue@ statement is illegal in the \verb@try@ clause.  (The
-reason is a problem with the current implementation --- this
-restriction may be lifted in the future).
-\stindex{return}
-\stindex{break}
-\stindex{continue}
-
-\section{Function definitions} \label{function}
-\indexii{function}{definition}
-
-A function definition defines a user-defined function object (see
-section \ref{types}):\footnote{The new syntax to receive arbitrary
-keyword arguments is not yet documented in this manual.  See chapter
-12 of the Tutorial.}
-\obindex{user-defined function}
-\obindex{function}
-
-\begin{verbatim}
-funcdef:        "def" funcname "(" [parameter_list] ")" ":" suite
-parameter_list: (defparameter ",")* ("*" identifier [, "**" identifier] 
-                                    | "**" identifier 
-                                    | defparameter [","])
-defparameter:   parameter ["=" condition]
-sublist:        parameter ("," parameter)* [","]
-parameter:      identifier | "(" sublist ")"
-funcname:       identifier
-\end{verbatim}
-
-A function definition is an executable statement.  Its execution binds
-the function name in the current local name space to a function object
-(a wrapper around the executable code for the function).  This
-function object contains a reference to the current global name space
-as the global name space to be used when the function is called.
-\indexii{function}{name}
-\indexii{name}{binding}
-
-The function definition does not execute the function body; this gets
-executed only when the function is called.
-
-When one or more top-level parameters have the form {\em parameter =
-condition}, the function is said to have ``default parameter values''.
-Default parameter values are evaluated when the function definition is
-executed.  For a parameter with a default value, the correponding
-argument may be omitted from a call, in which case the parameter's
-default value is substituted.  If a parameter has a default value, all
-following parameters must also have a default value --- this is a
-syntactic restriction that is not expressed by the grammar.%
-\footnote{Currently this is not checked; instead,
-{\tt def f(a=1,b)} is interpreted as {\tt def f(a=1,b=None)}.}
-\indexiii{default}{parameter}{value}
-
-Function call semantics are described in section \ref{calls}.  When a
-user-defined function is called, first missing arguments for which a
-default value exists are supplied; then the arguments (a.k.a. actual
-parameters) are bound to the (formal) parameters, as follows:
-\indexii{function}{call}
-\indexiii{user-defined}{function}{call}
-\index{parameter}
-\index{argument}
-\indexii{parameter}{formal}
-\indexii{parameter}{actual}
-
-\begin{itemize}
-
-\item
-If there are no formal parameters, there must be no arguments.
-
-\item
-If the formal parameter list does not end in a star followed by an
-identifier, there must be exactly as many arguments as there are
-parameters in the formal parameter list (at the top level); the
-arguments are assigned to the formal parameters one by one.  Note that
-the presence or absence of a trailing comma at the top level in either
-the formal or the actual parameter list makes no difference.  The
-assignment to a formal parameter is performed as if the parameter
-occurs on the left hand side of an assignment statement whose right
-hand side's value is that of the argument.
-
-\item
-If the formal parameter list ends in a star followed by an identifier,
-preceded by zero or more comma-followed parameters, there must be at
-least as many arguments as there are parameters preceding the star.
-Call this number {\em N}.  The first {\em N} arguments are assigned to
-the corresponding formal parameters in the way descibed above.  A
-tuple containing the remaining arguments, if any, is then assigned to
-the identifier following the star.  This variable will always be a
-tuple: if there are no extra arguments, its value is \verb@()@, if
-there is just one extra argument, it is a singleton tuple.
-\indexii{variable length}{parameter list}
-
-\end{itemize}
-
-Note that the `variable length parameter list' feature only works at
-the top level of the parameter list; individual parameters use a model
-corresponding more closely to that of ordinary assignment.  While the
-latter model is generally preferable, because of the greater type
-safety it offers (wrong-sized tuples aren't silently mistreated),
-variable length parameter lists are a sufficiently accepted practice
-in most programming languages that a compromise has been worked out.
-(And anyway, assignment has no equivalent for empty argument lists.)
-
-It is also possible to create anonymous functions (functions not bound
-to a name), for immediate use in expressions.  This uses lambda forms,
-described in section \ref{lambda}.
-\indexii{lambda}{form}
-
-\section{Class definitions} \label{class}
-\indexii{class}{definition}
-
-A class definition defines a class object (see section \ref{types}):
-\obindex{class}
-
-\begin{verbatim}
-classdef:       "class" classname [inheritance] ":" suite
-inheritance:    "(" [condition_list] ")"
-classname:      identifier
-\end{verbatim}
-
-A class definition is an executable statement.  It first evaluates the
-inheritance list, if present.  Each item in the inheritance list
-should evaluate to a class object.  The class's suite is then executed
-in a new execution frame (see section \ref{execframes}), using a newly
-created local name space and the original global name space.
-(Usually, the suite contains only function definitions.)  When the
-class's suite finishes execution, its execution frame is discarded but
-its local name space is saved.  A class object is then created using
-the inheritance list for the base classes and the saved local name
-space for the attribute dictionary.  The class name is bound to this
-class object in the original local name space.
-\index{inheritance}
-\indexii{class}{name}
-\indexii{name}{binding}
-\indexii{execution}{frame}
diff --git a/Doc/ref8.tex b/Doc/ref8.tex
deleted file mode 100644
index a9e688a..0000000
--- a/Doc/ref8.tex
+++ /dev/null
@@ -1,105 +0,0 @@
-\chapter{Top-level components}
-
-The Python interpreter can get its input from a number of sources:
-from a script passed to it as standard input or as program argument,
-typed in interactively, from a module source file, etc.  This chapter
-gives the syntax used in these cases.
-\index{interpreter}
-
-\section{Complete Python programs}
-\index{program}
-
-While a language specification need not prescribe how the language
-interpreter is invoked, it is useful to have a notion of a complete
-Python program.  A complete Python program is executed in a minimally
-initialized environment: all built-in and standard modules are
-available, but none have been initialized, except for \verb@sys@
-(various system services), \verb@__builtin__@ (built-in functions,
-exceptions and \verb@None@) and \verb@__main__@.  The latter is used
-to provide the local and global name space for execution of the
-complete program.
-\bimodindex{sys}
-\bimodindex{__main__}
-\bimodindex{__builtin__}
-
-The syntax for a complete Python program is that for file input,
-described in the next section.
-
-The interpreter may also be invoked in interactive mode; in this case,
-it does not read and execute a complete program but reads and executes
-one statement (possibly compound) at a time.  The initial environment
-is identical to that of a complete program; each statement is executed
-in the name space of \verb@__main__@.
-\index{interactive mode}
-\bimodindex{__main__}
-
-Under {\UNIX}, a complete program can be passed to the interpreter in
-three forms: with the {\bf -c} {\it string} command line option, as a
-file passed as the first command line argument, or as standard input.
-If the file or standard input is a tty device, the interpreter enters
-interactive mode; otherwise, it executes the file as a complete
-program.
-\index{UNIX}
-\index{command line}
-\index{standard input}
-
-\section{File input}
-
-All input read from non-interactive files has the same form:
-
-\begin{verbatim}
-file_input:     (NEWLINE | statement)*
-\end{verbatim}
-
-This syntax is used in the following situations:
-
-\begin{itemize}
-
-\item when parsing a complete Python program (from a file or from a string);
-
-\item when parsing a module;
-
-\item when parsing a string passed to the \verb@exec@ statement;
-
-\end{itemize}
-
-\section{Interactive input}
-
-Input in interactive mode is parsed using the following grammar:
-
-\begin{verbatim}
-interactive_input: [stmt_list] NEWLINE | compound_stmt NEWLINE
-\end{verbatim}
-
-Note that a (top-level) compound statement must be followed by a blank
-line in interactive mode; this is needed to help the parser detect the
-end of the input.
-
-\section{Expression input}
-\index{input}
-
-There are two forms of expression input.  Both ignore leading
-whitespace.
- 
-The string argument to \verb@eval()@ must have the following form:
-\bifuncindex{eval}
-
-\begin{verbatim}
-eval_input:     condition_list NEWLINE*
-\end{verbatim}
-
-The input line read by \verb@input()@ must have the following form:
-\bifuncindex{input}
-
-\begin{verbatim}
-input_input:    condition_list NEWLINE
-\end{verbatim}
-
-Note: to read `raw' input line without interpretation, you can use the
-built-in function \verb@raw_input()@  or the \verb@readline()@ method
-of file objects.
-\obindex{file}
-\index{input!raw}
-\index{raw input}
-\bifuncindex{raw_index}
-\ttindex{readline}